Python基础之数据类型
一、什么是数据类型？
在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：
整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).
- int。数字：主要用于运算。1 ，2,3...
- bool。判断真假：True, False.
- str。简单少量的储存数据，并进行相应的操作。name = 'alex',
- tuple。只读，不能更改。(1,'alex')
- list：大量有序数据，[1,'ses',True,[1,2,3],{'name':'jinxin'}]
- dict：大量数据，且是关联性比较强的数据 {'name':'jinxin','age':18,'name_list':['张三'，'李四']}
二，基础数据类型
2.1 数字int
2.1.1 十进制二进制转换
待补充
2.1.2 int操作方法
因为数字主要是用于计算，所以针对于数字可以使用的方法除了那些运算之外，没有什么经常会用的方法，python给咱们提供了一种方法：bit_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.
num = 10 print(num.bit_length()) # 当十进制用二进制表示时，最少使用的位数 # 运行结果: 4
2.2 布尔值bool
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
补充 int str bool之间的相互转换
# int ---> bool i = 100 print(bool(i)) # True # 非零即True i1 = 0 print(bool(i1)) # False 零即False # bool ---> int t = True print(int(t)) # 1 True --> 1 t = False print(int(t)) # 0 False --> 0 # int ---> str i1 = 100 print(str(i1)) # '100' # str ---> int # 全部由数字组成的字符串才可以转化成数字 s1 = '90' print(int(s1)) # 90 # str ---> bool s1 = '太白' s2 = '' print(bool(s1)) # True 非空即True print(bool(s2)) # False # bool ---> str t1 = True print(str(True)) # 'True'
2.3字符串str
2.3.1字符串的索引与切片
索引：
索引值以 0 为开始值，-1 为从末尾的开始位置。
切片：
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
# 对字符串进行索引，切片出来的数据都是字符串类型。 # 按照索引取值 # 从左至右有顺序，下标，索引。 s1 = 'qwertyuiop' s2 = s1[0] print(s2,type(s2)) s3 = s1[2] print(s3) s4 = s1[-1] print(s4) # 按照切片取值。 # 顾头不顾腚 s5 = s1[0:6] s51 = s1[:6] print(s5) print(s51) s6 = s1[6:] print(s6) # 切片步长 s7 = s1[:5:2] print(s7) print(s1[:]) # 倒序： s8 = s1[-1:-6:-1] print(s8)
2.3.2 字符串常用的方法
不会对原字符串进行任何操作，都是产生一个新的字符串
2.3.2.1 count()
统计字符串中的元素的个数
#数字符串中的元素出现的个数。 a1 = "dkfjdkfasf54" ret3 = a1.count("a",0,4) # 可切片 print(ret3)
2.3.2.2 startswith() 和 endswith()
startswith 判断是否以...开头 endswith 判断是否以...结尾
a4 = "dkfjdkfasf54" ret4 = a4.endswith('jdk',3,6) # 顾头不顾腚 print(ret4) # 返回的是布尔值 ret5 = a4.startswith("kfj",1,4) print(ret5)
2.3.2.3 split() （重要）
以什么分割，最终形成一个列表此列表不含有这个分割的元素。
# split 非常重要 # 默认按照空格分隔，返回一个列表 # 指定分隔符 # str ---> list s6 = '太白 女神 吴超' s6 = '太白:女神:吴超' l = s6.split(':') print(l) # 了解： s6 = ':barry:nvshen:wu' # print(s6.split(':')) print(s6.split(":",2))
2.3.2.4 format()
格式化输出的三种方式
res='{} {} {}'.format('egon',18,'male') res='{1} {0} {1}'.format('egon',18,'male') res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
2.3.2.5 strip()
直接调用除去左右两边的 空格，\n(换行)，\t(制表符)
s4 = ' \n星星\t' print(s4) s5 = s4.strip() print(s5)
也可以除去指定的字符串
s4 = 'rre太r白qsd' s5 = s4.strip('qrsed') print(s5) #==>太r白 name='*barry**' print(name.strip('*')) # 左边去除 print(name.lstrip('*')) # 右边去除 print(name.rstrip('*'))
2.3.2.6 join()
将列表中的字符串，连接为字符串类型
s1 = 'qwert' s2 = '+'.join(s1) print(s2,type(s2)) # ==> q+w+e+r+t <class 'str'> l1 = ['诸葛亮', '张飞', '关羽'] # 前提：列表里面的元素必须都是str类型 s3 = ':'.join(l1) print(s3,type(s3)) # ==> 诸葛亮:张飞:关羽 <class 'str'>
2.3.2.7 upper() 和 lower()
upper():字符串全部大写
lower()：字符串全部小写
s1 = s.upper() s2 = s.lower() print(s1,type(s1)) print(s2,type(s2))
2.3.2.8 replace()
msg = 'liebei 很nb,liebei是蜀国的皇帝，且liebei长得很帅' msg1 = msg.replace('liebei','诸葛亮') # 默认全部替换 msg2 = msg.replace('liebei','诸葛亮',2) print(msg1) # ==> 诸葛亮 很nb,诸葛亮是蜀国的皇帝，且诸葛亮长得很帅 print(msg2) # ==> 诸葛亮 很nb,诸葛亮是蜀国的皇帝，且liebei长得很帅
2.3.2.9 is系列
name1 = 'mingxing123' name2 = 'mingxing' name3 = '100' name4 = '100@' print(name1.isalnum()) #字符串由字母或数字组成 ==> True print(name2.isalpha()) #字符串只由字母组成 ==>True print(name1.isalpha()) #字符串只由字母组成 ==>False print(name3.isdecimal()) #字符串只由十进制组成 ==>True print(name4.isdecimal()) #字符串只由十进制组成 ==>False
2.3.2.10 capitalize()
首字母大写，其余变小写
s1 = 'mingXING' # capitalize 首字母大写，其余变小写 print(s1.capitalize()) # ==> Mingxing
2.3.2.11 swapcase()
大小写翻转
s1 = 'mingXING' print(s1.swapcase()) # ==> MINGxing
2.3.2.12 find() 和 index()
find :通过元素找索引，找到第一个就返回，找不到 返回-1
index:通过元素找索引，找到第一个就返回，找不到 报错
s1 = 'barry' print(s1.find('a')) print(s1.find('r')) print(s1.find('o')) print(s1.index('o'))
2.4List（列表）
对于字符串来说缺点有：
1，字符串只能存储少量的数据，对于大量的数据用字符串操作不方便也不易存储。
2，字符串存储的数据类型太单一，只能是字符串类型。
python给咱们也提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。List列表就属于容器类的数据类型。
他里面可以存放各种数据类型比如：
li = [‘星星’,123,Ture,(1,2,3,’weiwei’),[1,2,3,’小明’,],{‘name’:’wei’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
2.4.1 列表的创建
# 创建一个列表有三种方式： # 方式一：（常用） l1 = [1, 2, '星星'] # 方式二：（不常用） l1 = list() # 空列表 # l1 = list(iterable) # 可迭代对象 l1 = list('123') print(l1) # ['1', '2', '3'] # 方式三：列表推导式（后面的课程会讲到） l1 = [i for i in range(1,5)] print(l1) # [1, 2, 3, 4]
2.4.1 列表的索引与切片
2.4.1.1 索引
2.4.1.1 切片
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] tinylist = [123, 'runoob'] print (list) # 输出完整列表 print (list[0]) # 输出列表第一个元素 print (list[1:3]) # 从第二个开始输出到第三个元素 print (list[2:]) # 输出从第三个元素开始的所有元素 print (tinylist * 2) # 输出两次列表 print (list + tinylist) # 连接列表 # 输出的结果 # ['abcd', 786, 2.23, 'runoob', 70.2] # abcd # [786, 2.23] # [2.23, 'runoob', 70.2] # [123, 'runoob', 123, 'runoob'] # ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
2.4.2 列表的基本操作
2.4.2.1 列表的增
# append 追加，给列表的最后面追加一个元素 l = [1, 2, 'a'] l.append(666) print(l) # ==>[1, 2, 'a', 666] # insert 插入在列表的任意位置插入元素 l = [1, 2, 'a'] l.insert(1,'猪八戒') print(l) # ==>[1, '猪八戒', 2, 'a'] # extend 迭代着追加，在列表的最后面迭代着追加一组数据 l = [1, 2, 'a'] l.extend('太白a') print(l) # ==> [1, 2, 'a', '太', '白', 'a']
2.4.2.2 列表的删
# pop 通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素 l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] ret = l.pop(1) print(ret,l) # ==>zhubajie ['唐僧', 'sunwukong', '沙和尚'] # remove 通过元素删除列表中该元素 l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] l.remove('zhubajie') print(l) # ==> ['唐僧', 'sunwukong', '沙和尚'] # clear 清空列表 l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] l.clear() print(l) # ==> [] # del #按照索引删除该元素 l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] del l[2] print(l) # ==> ['唐僧', 'zhubajie', '沙和尚'] # 切片删除该元素 l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] del l[1:] print(l) # ==> ['唐僧'] # 切片(步长)删除该元素 l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] del l[::2] print(l) # ==> ['zhubajie', '沙和尚']
2.4.2.3 列表的改
# 按照索引改值 l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] l[0] = '男神' print(l) # ==> ['男神', 'zhubajie', 'sunwukong', '沙和尚'] # 按照切片改值(迭代着增加) l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] l[1:3] = 'abcdefg' print(l) # ==>['唐僧', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '沙和尚'] # # # 按照切片(步长)改值(必须一一对应) l = ['唐僧', 'zhubajie', 'sunwukong', '沙和尚'] print(l[::2]) l[::2] = '对应' print(l) # ==> ['对', 'zhubajie', '应', '沙和尚']
2.4.2.3 列表的查
切片去查，或者循环去查。
# 查： # 索引，切片（步长） for i in l1: print(i)
2.4.2.3 列表的其他操作
1. count （数）（方法统计某个元素在列表中出现的次数）
a = ["q", "w", "q", "r", "t", "y"] print(a.count("q")) # ==> 2
2. index（方法用于从列表中找出某个值第一个匹配项的索引位置）
a = ["q","w","r","t","y"] print(a.index("r")) # ==>2
3.reverse和sort
reverser():反转
sort():默认排序是从小到大，加上reverse=True时，从大到小排序。
l1 = [5, 4, 3, 7, 8, 6, 1, 9] l1.reverse() # 反转 ** print(l1) # ==> [9, 1, 6, 8, 7, 3, 4, 5] l1.sort() # 默认从小到大排序 l1.sort(reverse=True) # 从大到小排序 ** print(l1) # ==> [9, 8, 7, 6, 5, 4, 3, 1]
4.列表的相加和与数字相乘
# 列表可以相加 l1 = [1, 2, 3] l2 = [1, '诸葛亮', 2, 3, '刘备', '关羽'] print(l1 + l2) # ==> [1, 2, 3, 1, '诸葛亮', 2, 3, '刘备', '关羽'] # 列表与数字相乘 l1 = [1, 'daf', 3] l2 = l1 * 3 print(l2) # ==> [1, 'daf', 3, 1, 'daf', 3, 1, 'daf', 3]
列表的缺点：
1. 列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。
2. 列表只能按照顺序存储，数据与数据之间关联性不强。
列表的循环删除：
方式一：
li = [1, 1, 0, 0, 2, 3, 2, 12, 4, 1, 0, 0, 7, 0, 0, 9, 0, ] new_li = [x for x in li if x !=0]
方式2：
li = [1, 1, 0, 0, 2, 3, 2, 12, 4, 1, 0, 0, 7, 0, 0, 9, 0, ] for i in range(len(li) - 1, -1, -1): if li[i] == 0: del li[i] print(li)
2.5 tuple(元组)
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。所以元素只能查看。相对安全！
2.5.1 元组的索引与切片
同列表
tu1 = ('a', 'b', '明星', 3, 666) print(tu1[0]) # 'a' print(tu1[-1]) # 666 print(tu1[1:3]) # ('b', '明星') print(tu1[:-1]) # ('a', 'b', '明星', 3) print(tu1[::2]) # ('a', '明星', 666) print(tu1[::-1]) # (666, 3, '明星', 'b', 'a')
2.5.1 元组的其他操作方法
因为元组的特性，直接从属于元组的元素不能更改，所以元组只能查看。
# 可以利用for循环查询 tu1 = ('a', 'b', '星星', 3, 666) for i in tu1: print(i)
常用方法
index()：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。
count(): 获取某元素在列表中出现的次数
len():统计元组的长度
# index()：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。 tu = ('星星', [1, 2, 3, ], '张三', '李四') print(tu.index('星星')) # 0 # count(): 获取某元素在列表中出现的次数 tu = ('星星', '太白', '张三', '李四') print(tu.count('太白')) # 2 # len():统计元组的长度 tu1 = (1, 2, 3, 4, 84, 5, 2, 8, 2, 11, 88, 2) print(len(tu1))
2.6 dict(字典)
2.6.1 字典的初识
字典是解决list的缺点的。
数据类型的分类
不可变（可哈希）的数据类型：int，str，bool，tuple。
可变（不可哈希）的数据类型：list，dict，set。
字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：
Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。
Value:任意数据(int，str，bool，tuple，list，dict，set)，包括后面要学的实例对象等
在Python3.5版本（包括此版本）之前，字典是无序的。
在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。
当然，字典也有缺点：他的缺点就是内存消耗巨大。
2.6.2 字典的创建
# 方式1: dic = dict((('one', 1),('two', 2),('three', 3))) # dic = dict([('one', 1),('two', 2),('three', 3)]) print(dic) # {'one': 1, 'two': 2, 'three': 3} # 方式2: dic = dict(one=1,two=2,three=3) print(dic) # {'one': 1, 'two': 2, 'three': 3} # 方式3: dic = dict({'one': 1, 'two': 2, 'three': 3}) print(dic) # {'one': 1, 'two': 2, 'three': 3} # 方式4: 后面会讲到先了解 dic = dict(zip(['one', 'two', 'three'],[1, 2, 3])) print(dic) # 方式5: 字典推导式 后面会讲到 dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]} print(dic) # 方式6:利用fromkey后面会讲到。 dic = dict.fromkeys('abcd','星星') print(dic) # ==> {'a': '星星', 'b': '星星', 'c': '星星', 'd': '星星'} dic1 = dict.fromkeys('abc', 100) print(dic1) # ==> {'a': 100, 'b': 100, 'c': 100} dic2 = dict.fromkeys([1, 2, 3], 'xingxing') print(dic2) # ==> {1: 'xingxing', 2: 'xingxing', 3: 'xingxing'} # 坑：值共有一个,面试题 dic3 = dict.fromkeys([1, 2, 3], []) dic3[1].append(666) print(dic3) # ==> {1: [666], 2: [666], 3: [666]}
2.6.3 字典的常用方法
2.6.3.1 增
# 通过键值对直接增加 dic = {'name': '星星', 'age': 18} dic['weight'] = 75 # 没有weight这个键，就增加键值对 print(dic) # {'name': '星星', 'age': 18, 'weight': 75} dic['name'] = 'barry' # 有name这个键，就成了字典的改值 print(dic) # {'name': 'barry', 'age': 18, 'weight': 75} # setdefault dic = {'name': '星星', 'age': 18} dic.setdefault('height', 175) # 没有height此键，则添加 print(dic) # {'name': '星星', 'age': 18, 'height': 175} dic.setdefault('name', 'barry') # 有此键则不变 print(dic) # {'name': '星星', 'age': 18, 'height': 175} # 它有返回值 dic = {'name': '星星', 'age': 18} ret = dic.setdefault('name') print(ret) # 太白
2.6.3.2 删
# pop 通过key删除字典的键值对，有返回值，可设置返回值。 dic = {'name': '星星', 'age': 18} # ret = dic.pop('name') # print(ret,dic) # 太白 {'age': 18} ret1 = dic.pop('n', None) print(ret1, dic) # None {'name': '星星', 'age': 18} # popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值 dic = {'name': '星星', 'age': 18} ret = dic.popitem() print(ret, dic) # ('age', 18) {'name': '星星'} # clear 清空字典 dic = {'name': '星星', 'age': 18} dic.clear() print(dic) # {} # del # 通过键删除键值对 dic = {'name': '星星', 'age': 18} del dic['name'] print(dic) # {'age': 18} # 删除整个字典 del dic # 注意： # 将字典中键含有'k'元素的键值对删除 ==># 循环一个字典时，如果改变这个字典的大小，就会报错。 # RuntimeError: dictionary changed size during iteration dic = {'k1': '星星', 'k2': 'barry', 'k3': '星星', 'age': 18} for key in dic: if 'k' in key: dic.pop(key) print(dic) # 正解 l1 = [] for key in dic: if 'k' in key: l1.append(key) print(l1) for i in l1: dic.pop(i) print(dic) for key in list(dic.keys()): # ['k1', 'k2', 'k3','age'] if 'k' in key: dic.pop(key) print(dic)
2.6.3.3 改
# 通过键值对直接改 dic = {'name': '星星', 'age': 18} dic['name'] = 'barry' print(dic) # ==> {'name': 'barry', 'age': 18} # update dic = {'name': '星星', 'age': 18} dic.update(sex='男', height=175) print(dic) # ==> {'name': '星星', 'age': 18, 'sex': '男', 'height': 175} dic = {'name': '星星', 'age': 18} dic.update([(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]) print(dic) # ==> {'name': '星星', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'} dic1 = {"name": "星星", "age": 18, "sex": "male"} dic2 = {"name": "weiwei", "weight": 75} dic1.update(dic2) print(dic1) # ==> {'name': 'weiwei', 'age': 18, 'sex': 'male', 'weight': 75} print(dic2) # ==> {'name': 'weiwei', 'weight': 75}
2.6.3.4 查
# 通过键查询 # 直接dic[key](没有此键会报错) dic = {'name': '星星', 'age': 18} print(dic['name']) # 星星 # get()（重点） dic = {'name': '星星', 'age': 18} v = dic.get('name') print(v) # '太白' v = dic.get('name1') print(v) # None v = dic.get('name2','没有此键') print(v) # 没有此键 # keys() dic = {'name': '星星', 'age': 18} print(dic.keys()) # dict_keys(['name', 'age']) # values() dic = {'name': '星星', 'age': 18} print(dic.values()) # dict_values(['星星', 18]) # items() dic = {'name': '星星', 'age': 18} print(dic.items()) # dict_items([('name', '星星'), ('age', 18)])
2.6.3.5 其他操作
key_list = dic.keys() print(key_list) 结果: dict_keys(['剑圣', '哈啥给', '大宝剑']) # 一个高仿列表,存放的都是字典中的key # 并且这个高仿的列表可以转化成列表 print(list(key_list)) # 它还可以循环打印 dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'} for i in dic: print(i) value_list = dic.values() print(value_list) 结果: dict_values(['易', '剑豪', '盖伦']) #一个高仿列表,存放都是字典中的value # 并且这个高仿的列表可以转化成列表 print(list(value_list)) # 它还可以循环打印 for i in dic.values(): print(i) key_value_list = dic.items() print(key_value_list) 结果: dict_items([('剑圣', '易'), ('哈啥给', '剑豪'), ('大宝剑', '盖伦')]) # 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值 # 并且这个高仿的列表可以转化成列表 print(list(key_value_list )) # 它还可以循环打印 dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'} for i in dic.items(): print(i) 结果： ('剑圣', '易') ('哈啥给', '剑豪') ('大宝剑', '盖伦')
a,b = 1,2 print(a,b) 结果: 1 2 a,b = ('你好','世界') # 这个用专业名词就叫做元组的拆包 print(a,b) 结果: 你好 世界 a,b = ['你好','大飞哥'] print(a,b) 结果: 你好 世界 a,b = {'汪峰':'北京北京','王菲':'天后'} print(a,b) 结果: 汪峰 王菲 for k,v in dic.items(): print('这是键',k) print('这是值',v)
2.6.4 字典的嵌套
dic = { 'name':'汪峰', 'age':48, 'wife':[{'name':'国际章','age':38}], 'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'} } # 1. 获取汪峰的名字。 print(dic['name']) # 2.获取这个字典：{'name':'国际章','age':38}。 print(dic['wife'][0]) # 3. 获取汪峰妻子的名字。 print(dic['wife'][0]['name']) # 4. 获取汪峰的第三个孩子名字。 print(dic['children']['girl_three'])
2.7 集合set（了解）
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
2.7.1 集合的创建
set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2) # {1, 2, 'barry'} {1, 2, 'barry'}
2.7.2 集合的增
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)
#update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)
2.7.3 集合的删
set1 = {'alex','wusir','ritian','egon','barry'}
set1.remove('alex') # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
2.7.3 集合的其他操作
2.7.3.1 交集。（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
2.7.3.2 并集。（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}
2.7.3.3 差集。（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
2.7.3.4 反交集。 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
2.7.3.5子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
2.7.3.6 frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry') print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
三， 其他（for，enumerate，range）
3.1 for
for循环：用户按照顺序循环可迭代对象的内容。
msg = '用户按照顺序循环可迭代对象的内容。' for item in msg: print(item) li = ['星星','','女神','egon','太白'] for i in li: print(i) dic = {'name':'太白','age':18,'sex':'man'} for k,v in dic.items(): print(k,v)
3.2 enumerate
枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['alex', '银角', '女神', 'egon', '太白'] for i in enumerate(li): print(i) ''' (0, 'alex') (1, '银角') (2, '女神') (3, 'egon') (4, '太白') ''' for index, name in enumerate(li, 1): print(index, name) ''' 1 alex 2 银角 3 女神 4 egon 5 太白 ''' for index, name in enumerate(li, 100): # 起始位置默认是0，可更改 print(index, name) ''' 100 alex 101 银角 102 女神 103 egon 104 太白 '''
3.3 range
range():指定范围，生成指定数字
for i in range(1,10): print(i) for i in range(1,10,2): # 步长 print(i) for i in range(10,1,-2): # 反向步长 print(i)
4，Python新特性:f-string（重要）
f-strings 是python3.6开始加入标准库的格式化输出新的写法，这个格式化输出比之前的%s 或者 format 效率高并且更加简化，非常的好用，以后再用格式化输出这就是唯一的选择。
4.1，简单例子
他的结构就是F(f)+ str的形式，在字符串中想替换的位置用{}展位，与format类似，但是用在字符串后面写入替换的内容，而他可以直接识别。碉堡了。
name = '星星' age = 18 sex = '男' msg = F'姓名：{name},性别：{age}，年龄：{sex}' # 大写字母也可以 msg = f'姓名：{name},性别：{age}，年龄：{sex}' print(msg) ''' 输出结果： 姓名：星星,性别：18，年龄：男 '''
4.2，任意表达式
print(f'{3*21}') # 63 name = 'barry' print(f"全部大写：{name.upper()}") # 全部大写：BARRY # 字典也可以 teacher = {'name': '星星', 'age': 18} msg = f"The teacher is {teacher['name']}, aged {teacher['age']}" print(msg) # The comedian is 星星, aged 18 # 列表也行 l1 = ['星星', 18] msg = f'姓名：{l1[0]},年龄：{l1[1]}.' print(msg) # 姓名：星星,年龄：18.
4.3，插入表达式
可以用函数完成相应的功能，然后将返回值返回到字符串相应的位置
def sum_a_b(a,b): return a + b a = 1 b = 2 print('求和的结果为' + f'{sum_a_b(a,b)}')
4.4，多行f
name = 'barry' age = 18 ajd = 'handsome' # speaker = f'''Hi {name}. # You are {age} years old. # You are a {ajd} guy!''' speaker = f'Hi {name}.'\ f'You are {age} years old.'\ f'You are a {ajd} guy!' print(speaker)
5.5 其他
print(f"{{73}}") # {73} print(f"{{{73}}}") # {73} print(f"{{{{73}}}}") # {{73}} m = 21 # ! , : { } ;这些标点不能出现在{} 这里面。 # print(f'{;12}') # 报错 # 所以使用lambda 表达式会出现一些问题。 # 解决方式：可将lambda嵌套在圆括号里面解决此问题。 x = 5 print(f'{(lambda x: x*2) (x)}') # 10
总结：f-string的格式化输出更加简洁，方便，易读。而且他的处理速度对之前的%s 或者format 有了较高的提升，所以以后尽量使用此种格式化输出。
浙公网安备 33010602011771号