10.基本数据类型及内置函数
小蛙有话说环节
与诸君共勉，愿诸君明天依旧光芒万丈。好记性不如烂笔头，让我们一起努力。小蛙今天也是收获满满！！！
小声bb环节：我说的很小声你们应该听不见（你们要是不学习，本蛙可就要超过你们了）
1. 引子
数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作int类型） ，单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等)，这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率， python针对这些常用的操作，为每一种数据类型内置了一系列方法。本章的主题就是带大家详细了解下它们，以及每种数据类型的详细定义、类型转换。
2. 数字类型int与float
2.1. 定义
# 1、定义：
# 1.1 整型int的定义
age=10 # 本质age = int(10)
# 1.2 浮点型float的定义
salary=3000.3 # 本质salary=float(3000.3)
# 注意：名字+括号的意思就是调用某个功能，比如
# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能
2.2. 类型转换(python中不同数据类型之间无法直接交互)
# 1、数据类型转换
# 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
s = '123'
res = int(s)
print(res,type(res)) # (123, <class 'int'>)
print(int(11.2)) # 11
print(int('12.3')) # 错误演示：字符串内包含了非整数符号.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '12.3'
# 1.2 进制转换
# 十进制转其他进制
print(bin(3)) # '0b11' 0b二进制
print(oct(9)) # '0o11' 0o八进制
print(hex(17)) # '0x11' # 0x十六进制
# 其他进制转十进制
print(int('0b1100', 2)) # 12 二进制转十进制
print(int('0o17', 8)) # 15 八进制转十进制
print(int('0x800', 16)) # 2048 十六进制转十进制
# 1.3 float同样可以用来做数据类型的转换
>>> s = '12.3'
>>> res=float(s)
>>> res,type(res)
(12.3, <class 'float'>)
3. 字符串
3.1 定义：
# 定义：在单引号\双引号\三引号内包含一串字符
name1 = 'jason' # 本质:name = str('任意形式内容')
name2 = "lili" # 本质:name = str("任意形式内容")
name3 = """ricky""" # 本质:name = str("""任意形式内容""")
3.2 类型转换
# 数据类型转换：str()可以将任意数据类型转换成字符串类型，例如
>>> type(str([1,2,3])) # list->str
<class 'str'>
>>> type(str({"name":"jason","age":18})) # dict->str
<class 'str'>
>>> type(str((1,2,3))) # tuple->str
<class 'str'>
>>> type(str({1,2,3,4})) # set->str
<class 'str'>
3.3 使用
3.3.1 优先掌握的操作
str = 'hello world!!'
# 1. 按索引取值（正向取，反向取）：
# 1.1 正向取（从左往右）
print(str[1]) # e
# 1.1 反向取（负号表示从右往左）
print(str[-3]) # d
# 1.3 对于str来说，只能按照索引取值，不能改
print(str1[0]='H') # 报错TypeError
# 2. 切片：索引的拓展应用，从一个大字符串中拷贝出一个子字符串（顾头不顾尾，步长）
res = str[0:5:]
print(res) #hello 顾头不顾尾，只能取到 0，1,2，3,4
#步长为2
res = str[0:5:2]
print(res) #hlo
#反向步长（了解）
res = str[5:0:-1] #默认的切片方向都是从左到右，-1修改成从右往左
print(res)
# 复制字符串 给新的变量名
res = str[::]
print(res)
# 反向切片
res = str[::-1]
print(res)
# 3.长度len
# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
print(len(str)) # 13 空格也算字符
# 4.成员运算 in 和 not in
# 4.1 int:判断hello 是否在 str里面
print('hello' in str)
True
# 4.2 not in:判断tony 是否不在 str里面
print('tony' not in str)
True
# 5.strip移除字符串首尾指定的字符（默认移除空格）
# 5.1. 括号内不指定字符，默认移除首尾空白字符（空格、\n、\t）
str1 = ' Raffi is grape juice '
print(str.strip())
# 5.2 括号内指定字符，移除首尾指定的字符
# str2 = '**tony**'
# str2.strip('*') # tony
# strip 只去两边的，不去中间
str2 = '***faf***fadf**'
print(str2.strip('*')) # faf***fadf
n1 = '##$$jason$$$##'
print(n1.strip('#$')) # jason
# 6.切分split
# 6.1 括号内不指定字符，默认以空格作为切分符号，切割后的结构是一个列表
str1 = 'Raffi is grape juice'
res = str1.split()
print(res) #['Raffi', 'is', 'grape', 'juice']
# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
str4 = '127.10.10.234'
res1 = str4.split('.')
print(res1) #['127', '10', '10', '234']
# 6.2.1 指定分割次数
str5 = '127.10.10.234'
res2 = str5.split('.',1) # 分割一次
print(res2) # ['127', '10.10.234']
3.3.2 需要掌握的操作
- strip，lstrip，rstrip
str2 = '***faf***fadf**'
print(str2.strip('*')) # faf***fadf 去掉左右两边的指定字符
print(str2.lstrip('*')) # faf***fadf** 去掉左边的指定字符
print(str2.rstrip('*')) # ***faf***fadf 去掉右边的指定字符
- lower(),upper()
str1 = 'Raffi is grape juice'
res = str1.lower()
res1 = str1.upper()
print(res) # raffi is grape juice 将英文字符全部变成小写字母
print(res1) # RAFFI IS GRAPE JUICE 将英文字符全部变成大写字母
- startswith,endswith
# 3. startswith,endswith
str1 = 'Raffi is grape juice'
# startswith()判断字符串是否以括号内指定的字符开头，结果为True或False
print(str1.startswith('Raffi')) #True
print(str1.startswith('cc')) #False
# endswith()判断字符串是否以括号内指定的字符串结尾，结果为True或False
print(str1.endswith('juice')) #True
- split,rsplit将字符串切成列表
# split会按照从左到右的顺序对字符串进行切分，可以制定切割次数
str5 = '127.10.10.234'
print(str5.split('.',1)) # ['127', '10.10.234']
# rsplit刚好与split相反，从右往左切割，可以制定切割次数
print(str5.rsplit('.',1)) # ['127.10.10', '234']
- join
str4 = ['127', '10.10.234']
# 从列表中取出多个字符串，然后按照.作为分隔符进行拼接
print('.'.join(str4)) #127.10.10.234
# 从可迭代对象中取出多个字符串，然后%按照指定的分隔符进行拼接，拼接的结果为字符串，不同数据类型不能互相拼接
print('%'.join('hello')) #h%e%l%l%o
- replace
# 用新的字符替换字符串中旧的字符
str7 = 'my name is tony, my age is 18!' # 将小写my 改成大写my 没有指定个数 默认全部改写
str7 = str7.replace('my','MY') # 语法：replace（'旧内容'，'新内容'）
#指定修改的个数
str7 = str7.replace('my','MY',1) #只把一个my改成MY
print(str7)
- isdigit
# 判断字符串是否是纯数字，返回结果为Tur或False
str8 = '123'
print(str8.isdigit()) # True
str8 = '12ff3'
print(str8.isdigit()) # False
3.3.3 了解操作
# 1.find,rfind,index,rindex,count
# 1.1 find:从指定范围内查找字字符串的起始开始索引，找得到则返回1，找不到返回-1
msg = 'hello wyz hahaha'
print(msg.find('w')) # 6 返回查找的字符串在大字串中的起始索引
print(msg.find('ha')) # 10
print(msg.find('ss')) # -1
# 1.2 index:同find,但在找不到时会报错
print(msg.index('w')) # 6
# 1.3 count:统计字符串在大字符串中出现的次数
print(msg.count('a')) # 3
print(msg.count('ha')) # 3
# 2.center,ljust,rjust,zfill
name = 'tony'
# 总宽度为30，字符串居中显示，长度不够用*补充
print(name.center(30,'*')) # *************tony*************
# 总宽度为30，字符串居左显示，长度不够用*补充
print(name.ljust(30,'*')) # tony**************************
# 总宽度为30，字符串居右显示，长度不够用*补充
print(name.rjust(30,'*')) # **************************tony
#总宽度为30，字符串居右显示，不够用0补充
print(name.zfill(30)) # 00000000000000000000000000tony
# 3.expandtabs
name = 'tony\thello' #tony hello \t表示制表符(tab键)
print(name)
print(name.expandtabs(2)) #tony hello 修改制表符代表的空格数
# # 4.captalize,swapcase,title
#4.1 capitalize：首字母大写，后面统一小写
name = 'tony hello'
print(name.capitalize()) # Tony hello
#4.2 swapcase：大小写翻转
name1 = 'Tony Hello'
print(name1.swapcase()) # tONY hELLO
#4.3 title：每个单词的首字母大写
name2 = 'tony hello'
print(name2.title()) # Tony Hello
#5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字
#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit()
False
#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal()
True
>>> num3.isdecimal()
False
>>> num4.isdecimal()
False
#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric()
True
>>> num3.isnumeric()
True
>>> num4.isnumeric()
True
# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
# 6.is其他
name = 'tom123'
print(name.isalnum()) # True 字符串中是否既有字母也有数字
print(name.isalpha()) # False 字符串是否只有字母
print(name.isidentifier()) # True
print(name.islower()) # True 字符串是否全是小写
print(name.isupper()) # True 字符串是否全是大写
print(name.istitle()) # False 字符串中的单词首字母是否都是大写
print(name.isspace()) # False 字符串是否全是空格
4. 列表
4.1. 定义
# 定义：在[]内，用逗号分隔开多个任意数据类型的值
l1 = [1,'a',[1,2]] # 本质:l1 = list([1,'a',[1,2]])
4.2. 类型转换
# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
print(list('qrqe')) # ['q', 'r', 'q', 'e']
print(list([1,2,'ad'])) # [1, 2, 'ad']
print(list({"name":"jason","age":18})) # ['name', 'age'] 转化成列表的是key值
print(list((1,2,3))) # [1, 2, 3]
4.3. 使用
4.3.1. 优先掌握的操作
# ps： 列表也可以+和*
# 1.按索引存取值(正向存取+反向存取)：即可存也可以取
# 1.1 正向取(从左往右)
my_friends = ['tony', 'jason', 'jack']
print(my_friends[1]) # jason
# 1.2 反向取(负号表示从右往左)
print(my_friends[-1]) # jack
# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引值不存在则报错
my_friends = ['tony', 'jason', 'jack']
my_friends[1] = 'egon'
print(my_friends) # ['tony', 'egon', 'jack']
# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
my_friends = ['tony', 'jason', 'jack', 4, 5, 'tom']
print(my_friends[0:4]) # ['tony', 'jason', 'tom', 4]
# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
print(my_friends[0:4:2]) # ['tony', 'jack']
# 3.长度
print(len(my_friends)) # 6
# 4.成员运算in和not in
print('tony' in my_friends) # True
print(6 not in my_friends) # True
# 5.添加
# 5.1 append()列表尾部追加元素
my_friends = ['tony', 'jason', 'jack', 4, 5, 'tom']
my_friends.append('yy')
print(my_friends) # ['tony', 'jason', 'jack', 4, 5, 'tom', 'yy']
# 5.2 extend() 一次性在列表尾部添加多个元素
my_friends.extend(['q', 2, 'a', '3'])
print(my_friends) # ['tony', 'jason', 'jack', 4, 5, 'tom', 'yy', 'q', 2, 'a', '3']
# 5.3 insert()在指定位置插入元素
my_friends.insert(1,'sb') # 1 表示按索引位置插值
print(my_friends) ['tony', 'sb', 'jason', 'jack', 4, 5, 'tom', 'yy', 'q', 2, 'a', '3']
# 6.删除
# 6.1 del
del my_friends[2] # 删除索引为2的值'jason'
print(my_friends) # ['tony', 'sb', 'jack', 4, 5, 'tom', 'yy', 'q', 2, 'a', '3']
# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素（尾部弹出元素）
res = my_friends.pop()
print(res) #3 删除末尾元素3
res = my_friends.pop(2) # 指定索引为2元素并删除（制定索引弹出元素）
print(res) #jack 删除
# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
res = my_friends.remove(4) # 删除4
print(my_friends) # ['tony', 'sb', 'jack', 5, 'tom', 'yy', 'q', 2, 'a', '3']
# 7.reverse()颠倒列表内元素顺序
l = [11, 23, 24, 88]
l.reverse()
print(l) # [88, 24, 23, 11]
# 8.sort()给列表内所有元素排序
# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
l1 = [11, 9, 34, 8, 17]
l1.sort()
print(l1) # [8, 9, 11, 17, 34] 默认从小到大排序
l2 = ['aa', 'cc', 'ad', 'bb', 'ac']
l2.sort()
print(l2) # ['aa', 'ac', 'ad', 'bb', 'cc']
l1 = [11, 9, 34, 8, 17]
l1.sort(reverse=True) # reverse用来指定是否颠倒排序，默认False
print(l1) # [34, 17, 11, 9, 8]
# 8.2 了解知识
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
l1=[1,2,3]
l2=[2,] #
print(l2 > l1) # True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1='abc'
s2='az'
print(s2 > s1) # True s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
# 9.循环
# 循环遍历my_friends列表里面的值
my_friends = ['jason', 'egon', 1, 2]
for line in my_friends:
print(line) #jason egon 1 2
4.4. 列表补充知识（队列，堆栈）
# 队列（先进先出）
l = [1, 2, 3, 5]
for i in l:
print(i)
# 堆栈（先进后出）
count = 0
l = [1, 2, 3, 5]
i = len(l)
while count < i:
print(l.pop())
count +=1
5. 元组
5.1. 作用
元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的内存地址不能修改，即元组相当于不可改变的列表，用于记录多个固定不允许修改地址的值，单纯用于取
5.2. 定义方式
# 在括号内用逗号分隔开多个任意类型的值
t = (1, 'aa', 2, 3)
print(t,type(t)) # (1, 'aa', 2, 3) <class 'tuple'>
# 强调：当元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组。以后容器类型，无论内部有几个元素，都要加逗号，尤其只有一个元素的时候。
t = (1)
print(t, type(t)) # 1 <class 'int'>
t = ('1')
print(type(t)) # <class 'str'>
t = (1,)
print(t, type(t)) # (1,) <class 'tuple'>
5.3. 类型转换
# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
print(tuple('wdad')) # 结果：('w', 'd', 'a', 'd')
print(tuple([1,2,3])) # 结果：(1, 2, 3)
print(tuple({"name":"jason","age":18}) )# 结果：('name', 'age') 存的是key值
print(tuple((1,2,3))) # 结果：(1, 2, 3)
print(tuple({1,2,3,4})) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中
5.4. 使用
tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
# 1、按索引取值(正向取+反向取)：只能取 不能改否则报错！
print(tuple1[0]) # 1
print(tuple1[-2]) # 22
print(tuple1[0] = 'hehe') # 报错：TypeError:
# 1.1
t = (1, 'aa', 2, 3, [1, 33])
print(t, id(t)) # (1, 'aa', 2, 3, [1, 33]) 2079883531824
# t[4][1] = 123 # 可以改 列表是可变类型，元组嵌套字典一样可以改
# print(t, id(t)) # (1, 'aa', 2, 3, [1, 123]) 2079883531824
#t[4] = 123 # 可以改 列表是可变类型，元组嵌套字典一样可以改 #不可以改
#print(t, id(t)) # (1, 'aa', 2, 3, [1, 123]) 2079883531824
# 2、切片(顾头不顾尾，步长)
print(tuple1[0:6:2] ) # (1, 15000.0, 22)
# 3、长度
print(len(tuple1)) # 6
# 4、成员运算 in 和 not in
print('hhaha' in tuple1 ) # True
print('hhaha' not in tuple1 ) #False
# 5、循环
for line in tuple1:
print(line)
6. 字典
6.1. 定义方式
# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，且key唯一，通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
6.2. 类型转换
# 转换1：
l = [['name','wyz'], ('age',18)]
print(dict(l)) # {'name': 'wyz', 'age': 18}
# 转换2：fromkeys会从元组中取出每个值当作key，然后与None组成key：value（默认使用None）
print({}.fromkeys(('name', 'age', 'sex'))) # {'name': None, 'age': None, 'sex': None}
print({}.fromkeys(('name', 'age', 'sex'), None)) # {'name': None, 'age': None, 'sex': None}
6.3. 使用
6.3.1. 优先掌握的操作
# 1. 按key存取值：可存可取
# 1.1 取
dic = {
'name': 'zye',
'age': 18,
'hobbies': ['games', 'sleep']
}
print(dic['name']) # zye
print(dic['hobbies'][0]) # games
# 1.2 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
dic = {
'name': 'zye',
'age': 18,
'hobbies': ['games', 'sleep']
}
dic['name'] = 'wyz'
print(dic['name']) # wyz key（name）值存在，value（zye）修改成'wyz'
dic['gender'] = '1' # key('gender')值不存在，增加一个元素
print(dic) # {'name': 'wyz', 'age': 18, 'hobbies': ['games', 'sleep'], 'gender': '1'}
# 2、长度len
print(len(dic)) # 4
# 3、成员运算in和not in
>>> 'name' in dic # 判断某个值是否是字典的key
True
# 4、删除
# 4.1. pop删除
dic.pop('name')
print(dic) # {'age': 18, 'hobbies': ['games', 'sleep'], 'gender': '1'}
res = dic.pop('name') # 删除key对应的value值
print(res) # wyz
# 4.1. popitem删除：随机删除，返回元组（删除对应的key，value）
res = dic.popitem()
# res = dic.popitem()
print(dic)
print(res) # ('gender', '1')
# 5.键keys()，值values()，键值对items()
# 获取字典所有的key
print(dic.keys()) # dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的values
print(dic.values()) # dict_values(['zye', 18, ['games', 'sleep']])
# 获取字典所有的键值对 打印成元组形式
print(dic.items()) # dict_items([('name', 'zye'), ('age', 18), ('hobbies', ['games', 'sleep'])])
# 6、循环
# 6.1 默认遍历的是字典的key
for key in dic:
print(key)
'''
name
age
hobbies
'''
# 6.2 只遍历key
for key1 in dic.keys():
print(key1)
'''
name
age
hobbies
'''
# 6.3 只遍历value
for values in dic.values():
print(values)
'''
zye
18
['games', 'sleep']
'''
# 6.4 遍历key与value
for dic1 in dic.items():
print(dic1)
'''
('name', 'zye')
('age', 18)
('hobbies', ['games', 'sleep'])
'''
6.3.2 需要掌握的操作
- get()
dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
# key存在，则获取key对应的value值
print(dic.get('k1')) # jason
# key不存在，不会报错而是默认返回None
print(dic.get('k4')) # None
# key不存在，可以设置默认返回值
print(dic.get('k4', 6262)) # 6262
# ps:字典取值建议使用get方法
- pop()
dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值
print(dic) # {'k1': 'jason', 'k3': 'JY'}
print(v) # Tony
- popitem()
dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
item = dic.popitem() # 删除并返回字典中的最后一对键和值。
print(dic) # {'k1': 'jason', 'k2': 'Tony'}
print(item) # ('k3', 'JY')
- updaet()
# 用新字典更新旧字典，有则修改，无则添加
dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
dic.update({'k1':'jc', 'k4':'wz'})
print(dic) # {'k1': 'jc', 'k2': 'Tony', 'k3': 'JY', 'k4': 'wz'}
- fromkeys()
# 快速生成字典
dic = dict.fromkeys(['k1', 'k2', 'k3'],None)
print(dic) # {'k1': None, 'k2': None, 'k3': None}
- setdefault()
dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
# key不存在则新增键值对，并将新增的value返回
res = dic.setdefault('k4', 44)
print(res) # 44
print(dic) # {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY', 'k4': 44}
# key存在则不做任何修改，并返回已存在的key对应的value值
res = dic.setdefault('k3', 44)
print(res) # JY
print(dic) # {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
7. 集合
7.1. 作用
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算，集合没有重复的值
7.2. 定义
'''
定义：在｛｝内用逗号分隔开多个元素，集合具备以下三个特点：
1. 每个元素必须是不可变类型 不可嵌套字典、列表
s = {1, 2, {'a': 1}, 't'}
print(s) # TypeError: unhashable type: 'dict'
2. 集合内没有重复的元素
3. 集合内元素无序
'''
s = {1, 2, 't'}
print(s, type(s)) # {1, 2, 't'} <class 'set'>
# 注意1： 列表里而行事索引对应值，字典是key对应值，均可以取单个指定的值，而集合类型既没有索引也没有可以与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求
# 注意2：{}既可以用于定义dict，也可以用定义集合，但是字典内的元素必须是key：value的格式，现在我们向定义一个空字典和空集合，该如何准确去定义两者？
dic = {} # 空字典
s = set() # 空集合
7.3. 类型转换
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
7.4. 使用
7.4.1 关系运算
# 合集 并集
friend1 = {'wyz', 'egon', 'jason', 'kevin'}
friend2 = {'wyy', 'egon', 'jason', 'jj'}
print(friend1 | friend2) # 共同元素只保留一个 {'egon', 'wyy', 'jason', 'wyz', 'kevin', 'jj'}
# 2.交集(&):求两个集合的共同元素
print(friend1 & friend2) # {'egon', 'jason'}
# 3.差集（-）
print(friend1 - friend2) # {'kevin', 'wyz'} 求用户1独有的用户
print(friend2 - friend2) # set()
print(friend2 - friend1) # {'jj', 'wyy'} 求用户2独有的用户
# 4.对称差集（^）
print(friend1 ^ friend2) # {'jj', 'kevin', 'wyz', 'wyy'} 两个集合独有的元素
# 5. 值是否相等（==）
print(friend2 == friend1) # False
# 父集 ： 一个集合是否包含另外一个集合
# 6.1 包含则返回True
s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 > s2) # True
print(s1 >= s2) # True
# 6.2 不存在包含关系，则返回False
s1 = {1, 2, 3}
s2 = {1, 2, 4}
print(s1 > s2) # False
print(s1 >= s2) # False、
# 7. 子集
print(s1 < s2) # False
print(s1 <= s2) # False
7.4.2. 去重
集合去重有局限性
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
示例如下
1 = ['a', 'a', 'b', 1, 2]
ss1 = set(l1) # 将列表l转成了集合
print(ss1) # {'a', 1, 'b', 2}
new_l1 = list(ss1) # 再将集合转回了列表，这样就去了重复，但是打乱了顺序
print(new_l1) # ['a', 1, 'b', 2]
# 针对不可变类性，并且保证顺序则需要我们自己写代码实现，例如
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l1 = []
for dic in l:
if dic not in new_l1:
new_l1.append(dic)
print(new_l1)
# [{'name': 'lili', 'age': 18, 'sex': 'male'}, {'name': 'jack', 'age': 73, 'sex': 'male'}, {'name': 'tom', 'age': 20, 'sex': 'female'}]
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
7.4.3. 其他操作
# 1.长度
s={'a','b','c'}
print(len(s)) # 3
# 2.成员运算
print('c' in s) # True
# 3.循环
for item in s:
print(item)
'''
c
a
b
'''
7.5. 练习
"""
一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
"""
pythons = {'jason', 'egon', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs) # {'gangdan'}
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs) # {'ricky', 'gangdan', 'kermit', 'biubiu', 'kevin', 'jason', 'egon', 'tony'}
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs) # {'ricky', 'jason', 'kevin', 'egon', 'biubiu'}
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs) # {'jason', 'kermit', 'ricky', 'kevin', 'tony', 'egon', 'biubiu'}
8. 数据类型总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Edyc9tTn-1622707700242)(python基础08——基本数据类型及内置方法.assets/01.jpg)]
9.练习
'''
1.将列表中大于等于66的元素放入字典k1键对应的列表中
将列表中小于66的元素放入字典k2键对应的列表中
nums=[11,22,33,44,55,66,77,88,99,90]
dic={
'k1':[],
'k2':[]
}
思路：for循环一个一个取值比大小
'''
nums=[11,22,33,44,55,66,77,88,99,90]
dic={
'k1':[],
'k2':[]
}
for i in nums:
if i < 66:
dic['k2'].append(i)
else:
dic['k1'].append(i)
print(dic) # {'k1': [66, 77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}
'''
2.s='hello jason jason say hello sb sb sb'
统计字符串中每个单词出现的次数,并将得出的次数按照以下规则存入字典
{'jason':2,...}
'''
# 版本一
s = 'hello jason jason say hello sb sb sb'
s_spl = s.split() # 把字符串分割
# 去重
new_l1 = [] # 新字典的key值
for j in s_spl:
if j not in new_l1:
new_l1.append(j)
new_l2 = [] # 新字典的value值
for i in new_l1:
str_count = s_spl.count(i) # 单词重复的个数
new_l2.append(str_count)
dic = dict(zip(new_l1, new_l2))
print(dic) # {'hello': 2, 'jason': 2, 'say': 1, 'sb': 3}
# 版本二
s = 'hello jason jason say hello sb sb sb'
s_spl = s.split() # 把字符串分割
dic = {}
for i in s_spl:
if dic.get(i) == None:
dic[i] = 1
else:
dic[i] +=1
print(dic) # {'hello': 2, 'jason': 2, 'say': 1, 'sb': 3}
# 版本三
s = 'hello jason jason say hello sb sb sb'
s_spl = s.split() # 把字符串分割
# 去重
new_l1 = [] # 新字典的key值
for j in s_spl:
if j not in new_l1:
new_l1.append(j)
dic = {}
for i in new_l1:
str_count = s_spl.count(i) # 单词重复的个数
dic[i] = str_count
print(dic) # {'hello': 2, 'jason': 2, 'say': 1, 'sb': 3}
集合练习
'''
练习1.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
'''
pythons = {'alex', 'egon', 'yuanhao', 'wupeiqi', 'gangdan', 'biubiu'}
linuxs = {'wupeiqi', 'oldboy', 'gangdan'}
# 1.求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs) # {'gangdan', 'wupeiqi'}
# 2.求出所有报名的学生名字集合
print(pythons | linuxs) # {'alex', 'biubiu', 'gangdan', 'egon', 'yuanhao', 'oldboy', 'wupeiqi'}
# 3.求出只报名python课程的学员名字
print(pythons - linuxs) # {'egon', 'yuanhao', 'alex', 'biubiu'}
# 4.求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs) # {'alex', 'biubiu', 'egon', 'yuanhao', 'oldboy'}
'''
练习2.去重并且保留原来的顺序
l = [11,22,33,22,22,33,11,22,55,66,66,77,77]
1.去重不保留顺序
2.去重并且保留顺序
'''
l = [11, 22, 33, 22, 22, 33, 11, 22, 55, 66, 66, 77, 77]
s = set(l)
new_l1 = list(s)
print(new_l1) # [33, 66, 11, 77, 22, 55]
new_l2 = []
for i in l:
if i not in new_l2:
new_l2.append(i)
print(new_l2) # [11, 22, 33, 55, 66, 77]
结束收工环节
6不6，就是这么简单，就是这么快乐，就是这么详细，愿诸君能在代码的世界里自由的翱翔。
内容有点多，一定要好好吸收。
本蛙要去恰饭了，嗝。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
