Python_Base_3

Python基础第三天

---

数据类型

基本数据类型分为三类：

数值类型、序列类型、散列类型

数值类型：

可以表示数字、数值
int 整型>>整数
float 浮点型>>小数
bool 布尔型>>用于判断/作为数值(True/False)进行运算

序列类型：

可以存储多个数据的一种数据类型
序列中每个元素都有属于自己的编号

s = 'CSDN博客论坛'
print(s[0], "==", s[-8])    # 第一个字符索引值为0/-8
print(s[7], "==", s[-1])    # 起始字符索引值为7/-1

# C == C
# 坛 == 坛

可变类型和不可变类型：

可变类型：列表、字典、集合
不可变类型：数字、字符、元组

s = "hello world"
print(s)
s[0] = 'a'
print(s)
# 报错（不可变）

字符串

内置功能

语法：字符串名.方法名()

find()/rfind()

范围性查找子串，返回索引值，没有返回-1。
语法：字符串名.find(str,beg=0,end=len(string))
str --> 指定检索的字符串
beg --> 开始的索引，默认为0
end --> 结束的索引，默认为字符串的长度

s = 'hello world'
print(s.find('h'))    # 0
print(s.find('world'))    # 6 (返回首个字符的下标)
print(s.find('worldd'))   # -1
print(s.rfind('o'))   # 7 (从后向前查找）

index()

和find()基本一样，不过找不到会报错。

s = 'hello world'
print(s.index('h'))    # 0
print(s.index('world'))    # 6 (返回首个字符的下标)
print(s.index('worldd'))   # 找不到就会报错

---

count()

找到字符串个数，没有返回0。
s = 'hello world'
print(s.count('o'))   # 2

---

strip()

去除字符串两边的空格、换行符、制表符，得到新字符串。

yzm = input('请输入四位验证码：')
data = yzm.strip()   # 进行去空操作
if data == "ABCD":
    print("验证码正确")
else:
    print("验证码错误")

startswith()/endswith()

判断字符是否以XX开头/结尾、得到一个布尔值。

ad = input("请输入所在地址：")
if ad.endswith("村"):
    print("农业户口")
else:
    print("非农户口")

isdigit()

判断字符是否是数字组成，返回结果为True/False

n1 = input("请输入第一个数字：")
n2 = input("请输入第二个数字：")
if n1.isdigit() and n2.isdigit():
    data = int(n1)+int(n2)
    print(data)
else:
    print("请正确输入数字")

---

lower()/upper()

将字符串变大写或小写，得到一个新字符
a = 'abc'
a1 = a.upper()
print(a1)   # ABC

---

split()

切分字符串，将字符串类型转列表

s = 'how are you'
print(s.split(" "))      # ['how', 'are', 'you'](以空格切分)

s = 'how,are,you'
print(s.split(","))      # ['how', 'are', 'you'](以逗号切分)

---

replace()

content = input('输入信息：')
content1 = content.replace("哦", "嗯！")
print(content1)

---

join()

将列表类型转换为字符串
arr = ["你", "和", "我", "是好朋友"]
print("".join(arr))   # 你和我是好朋友
print("-".join(arr))  # 你-和-我-是好朋友

---

字符串的公共功能

正向取（从左往右）/反向取（从右往左）

s = 'hello!!'
print(s[0])        # h
print(s[-3])        # o

 

正着数从0开始算，倒着数从-1开始算，超出报错。

len()

查看长度

s = 'hello!'

print(len(s))       # 6
print(s[len(s)-1])     # 取最后一个值，！
print(s[-len(s)])       # 取第一个值，h

切片

取左闭右开区间的,有步长

s = 'hello!!'
print(s[:])        # hello!!
print(s[0:5])        # hello
print(s[0:6:2])        # hlo
print(s[::-1])        # !!olleh（反向切片）

输入一串字符串并计算其中‘aeiou’出现的次数

用count()普通方式

s = input('请输入一串字符：')
print('a：'+str(s.count('a')))
print('e：'+str(s.count('e')))
print('i：'+str(s.count('i')))
print('o：'+str(s.count('o')))
print('u：'+str(s.count('u')))
 

使用遍历

s = input('请输入一串字符：')
for i in 'aeiou':
    print(i, ':', s.count(i))

---

列表list

存储同一个类别的数据，方便操作

animals = ['cats', 'dogs']  # 创建列表
animals.append('pigs')
print(animals)
# ['cats', 'dogs', 'pigs']

列表的增

append:

添加一个数据到列表最后一位
语法：列表名.append('内容')

insert:

添加一个数据到指定位置
语法：列表名.insert(下标位置，内容)

extend:

添加一个序列类型到最后一位，并被拆分
语法：列表名.extend(序列类型)

li = [1, 2, 3, 4, 5]
li.append(6)
print(li)         # [1, 2, 3, 4, 5, 6]
li.insert(0, '一花')
print(li)         # ['一花', 1, 2, 3, 4, 5, 6]
li.extend('二乃')
print(li)         # ['一花', 1, 2, 3, 4, 5, 6, '二', '乃']
li.extend(['三玖'])
print(li)          # ['一花', 1, 2, 3, 4, 5, 6, '二', '乃', '三玖']

列表的删

pop:

默认从最后一个位置删除一个值，也可以指定位置
语法：列表名.pop()/pop(下标)

remove:

删除一个指定的值，如果有多个就从第一个开始删
语法：列表名.remove(删除对象)

clear：

清空列表里面的所有数据
语法：列表名.clear()

del:

全局删除，可以删除一个变量
语法：列表名/列表名[下标]

li = [1, 2, 3, 4, 5, 6]
li.pop(-2)
print(li)          # [1, 2, 3, 4, 6]
li.pop()
print(li)          # [1, 2, 3, 4]
li.remove(1)
print(li)          # [2, 3, 4]
del li[1]
print(li)          # [2, 4]
li.clear()
print(li)          # []

列表的改

单个修改
直接通过下标进行修改
语法：列表名[下标]=内容
多个修改
通过切片方式进行修改(左闭右开区间)
语法：列表名[起点:终点]=数据1，数据2...

li = [1, 2, 3, 4, 5]
li[1] = 222
print(li)   # [1, 222, 3, 4, 5]
li[0:2] = 123, 456
print(li)   # [123, 456, 3, 4, 5]

列表的查

index:

根据内容获取指定数据的下标
语法：列表名：index(要找的内容)                               列表名 ：index(要找的内容，起点值)

count:

统计数据出现的次数
语法：列表名.count(要找的内容)

li = [1, 2, 4, 3, 2, 4, 4]
print(li.index(2))    # 1
print(li.index(2, 3))    # 4
print(li.count(4))    # 3

sort和sorted

全int的列表才可以排序
sort是在原列表上修改
让列表的内容按照顺序排列
语法：
        列表名.sort()-->升序
        列表名.sort(reverse=True)-->降序

li = [5, 2, 66, 34, 58]
li.sort()
print(li)          # [2, 5, 34, 58, 66]
li.sort(reverse=True)
print(li)          # [66, 58, 34, 5, 2]

sorted是返回一个新的列表
用变量赋值

列表生成式

生成1-10的列表

print(list(range(1, 11)))
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

普通的for循环创建列表

li = []
for i in range(1, 11):
    li.append(i)
print(li)

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

列表生成式生成

print([i for i in range(1, 11)])

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

---

元组

元组通常是使用小括号将所有元素包围起来的，或者将各元素用逗号隔开也可以，python会视它为元组
# 如：t = 'hello','world'

元组的查

count()

t = (123, 456, 'hello', 123)
print(t.count(123))    # 2
print(t.count(789))    # 0 (不会报错)

index()

t = (123, 456, 'hello', 123)
print(t.index(123))    # 0
print(t.index(123, 2))    # 3

功能

相加

data = ('一花', '二乃')+('三玖', '四叶')
print(data)    # ('一花', '二乃', '三玖', '四叶')

相乘

data = ('一花', '二乃')*2
print(data)    # ('一花', '二乃', '一花', '二乃')

获取长度

data = ('一花', '二乃', '三玖', '四叶')
print(len(data))    # 4

索引

data = ('一花', '二乃', '三玖', '四叶')
print(data[2])    # 三玖

切片

data = ('一花', '二乃', '三玖', '四叶')
print(data[1:3])   # ('二乃', '三玖')

步长

data = ('一花', '二乃', '三玖', '四叶')
print(data[::2])  # ('一花', '三玖')

for循环

data = ('一花', '二乃', '三玖', '四叶', '五月')
for i in data:
    if i == '四叶':
        continue
    print(i)
# 一花
# 二乃
# 三玖
# 五月

元组本身不可变，但元组中的可变元素可以改变(如列表)

t = (99, 88, ['一花', '三玖'], 55)
t[2][0] = '二乃'     

# 对元组中下标为2的这个列表中下标为0的数据进行更改
print(t)        # (99, 88, ['二乃', '三玖'], 55)

---

格式化输出

%方法

常用占位符
%s  -->  只能放字符串
%d  -->  只能放整数，若有小数点，会被切掉
%f  -->  只能放小数，默认保留6位
%.1f  -->  保留1位小数
%.2f  -->  保留2位小数
语法：("xxx%dxx%s"%(变量1，变量2))

name = 'XX'
age = 20
print('你好，我叫%s，今年%d岁了' % (name, age))
# 你好，我叫XX，今年20岁了

format()

语法：("xxx{}xx{}".format(变量1，变量2))

name = 'XX'
age = 20
print('你好，我叫{}，今年{}岁了'.format(name, age))
# 你好，我叫XX，今年20岁了

print('你好，我叫{}，今年{}岁了'.format('XX', 20))
# 你好，我叫XX，今年20岁了

自定义数据：

print('你好，我叫{1}，今年{0}岁了'.format(20, 'XX'))
# 你好，我叫XX，今年20岁了

f-format()

name = 'XX'
age = 20
print(f'你好，我叫{name}，今年{age}岁了')
# 你好，我叫XX，今年20岁了

 

print(f'你好，我叫{name[0]}，今年{age-1}岁了')
# 你好，我叫X，今年19岁了

---

散列类型

字典dict

用来保存一些典型的对应关系的数据类型，特点就是用键值对的方式来存储数据
键值对：键：key 值：value

语法：key:value --> (键:值)
re = {'一花': '21', '二乃': '20', '三玖': '18'}
print(re['一花'])        # 21

1. 无序的。用键值对的方式来确定
2. 不重复。若重复，取该键最后一个值
3. 可变性。字典里面数据是可变的

re = {'一花': '21', '二乃': '20', '三玖': '18'}
re['二乃'] = 22
print(re['二乃'])           # 22

通过key访问value
scores = {'语文': 88}
print(scores['语文'])   # 88
通过key添加key-value对
scores = {'语文': 88}
scores['数学'] = 90
print(scores)    # {'语文': 88, '数学': 90}
通过key删除key=value对
scores = {'语文': 88, '数学': 90}
del scores['语文']
print(scores)   # {'数学': 90}
通过key修改key-value对
fruits = {'bananas': 2.3, 'apples': 1.9}
fruits['apples'] = 2.1
print(fruits)    # {'bananas': 2.3, 'apples': 2.1}
通过key判断指定key-value是否存在
fruits = {'bananas': 2.3, 'apples': 1.9}
print('bananas' not in fruits)    # False
print('apples' in fruits)    # True

---

字典的常用方法

clear()
fruits = {'bananas': 2.3, 'apples': 1.9}
fruits.clear()
print(fruits)         # {}

get()
books = {'西游记': 81, '红楼梦': 12, '水浒传': 108, '三国演义': 3}
print(books.get('红楼梦'))     # 12
print(books.get('活着'))      # None
print(books['三体'])      # 报错

update()
books = {'西游记': 81, '红楼梦': 12, '水浒传': 108}
books.update({'西游记': 4, '三国演义': 3})
print(books)     # {'西游记': 4, '红楼梦': 12, '水浒传': 108, '三国演义': 3}

items()、keys()、values()
这三个方法分别会获取字典中所有的键值对、所有的key、所有的values。

用list()函数将他们的返回值转换为列表。

 

items（）

books = {'西游记': 81, '红楼梦': 12, '水浒传': 108, '三国演义': 3}
item = books.items()
print(item)   # dict_items([('西游记', 81), ('红楼梦', 12), ('水浒传', 108), ('三国演义', 3)])
print(list(item))   # [('西游记', 81), ('红楼梦', 12), ('水浒传', 108), ('三国演义', 3)]
print(list(item)[1])    # ('红楼梦', 12)

---

keys（）

books = {'西游记': 81, '红楼梦': 12, '水浒传': 108, '三国演义': 3}
key = books.keys()
print(list(key))   # ['西游记', '红楼梦', '水浒传', '三国演义']

---

values（）

books = {'西游记': 81, '红楼梦': 12, '水浒传': 108, '三国演义': 3}
value = books.values()
print(list(value))   # [81, 12, 108, 3]

setdefault()
books = {'西游记': 81, '红楼梦': 12, '水浒传': 108}
print(books.setdefault('三国演义', 3))               # 不存在，直接添加
print(books.setdefault('西游记', 4))                   # 存在，不改变原值
print(books)       # {'西游记': 81, '红楼梦': 12, '水浒传': 108, '三国演义': 3}

字典的公共功能

长度
info = {'name': 'XX', 'age': 20}
data = len(info)
print(data)   # 2

索引(键)
info = {'name': 'XX', 'age': 20}
print(info['name'])   # XX
print(info['height'])   # 报错

for循环
info = {'name': 'XX', 'age': 20}
for k in info:
    print(k)  # 获取所有键
# name
# age
info = {'name': 'XX', 'age': 20}
for v in info.values():
    print(v)
# XX
# 20
info = {'name': 'XX', 'age': 20}
for k, v in info.items():
    print(k, v)
# name XX
# age 20

---

集合set

只能存储不可变的数据类型，是无序的
# 语法：集合名={数据1，数据2...}

---

注意：
'''
li = []   # 空列表
tu1 = ()   # 空元组
str1 = ""   # 空字符串
dict1 = {}   # 空字典
set1 = set()  # 空集合
'''

---

集合用于：去重和数学关系运算
 

去重
li = [1, 1, 2, 3, 3, 5, 5, 5]
li1 = set(li)
li2 = list(li1)
print(li1)  # {1, 2, 3, 5}
print(li2)   # [1, 2, 3, 5]
数学运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 & set2)   # {3}
print(set1 | set2)   # {1, 2, 3, 4, 5}
print(set1 - set2)   # {1, 2}
print(3 in set2)    # True

集合的作用：

1. 存储非重复数据
2. 用于将序列类型去重
3. 逻辑判断 交集、并集、差集

增

add()
随机添加一个元素
s = {'五月'}
s.add('四叶')
print(s)   # {'四叶', '五月'}
s.add('三玖')
print(s)   # {'四叶', '三玖', '五月'}

删

pop()
随机删除一个元素
s = {'四叶', '三玖', '五月'}
s.pop()
print(s)  # {'四叶', '三玖'}
s.pop()
print(s)   # {'三玖'}

remove()
# 有参数，为要删除的元素。若元素不存在，报错
s = {'四叶', '三玖', '五月'}
s.remove('四叶')
print(s)   # {'五月', '三玖'}
s.remove('二乃')
print(s)   # 报错

discard()
# 与remove一样，不过元素不存在不会报错
s = {'四叶', '三玖', '五月'}
s.discard('二乃')
print(s)    # {'三玖', '五月', '四叶'}

clear()
s.clear()
print(s)   # set()

del
del s   # 整个删除变量
print(s)   # 报错(s不存在了)

公共功能：

• 长度
• for循环
• 减(计算差集)
   

---

数值类型 int、float、bool --> 存储一个数值
序列类型 str、list、tuple --> 存储多个数值
散列类型的特性：无序，内部元素不重复(无下标)

可变类型：列表，字典，集合

不可变类型：数字，字符串，元组