爱站程序员基地本篇文章介绍了python语法入门之基本数据类型及内置方法，了解有限掌握层级及数据类型处理的方法有哪些，下面我们一起来仔细看看吧~~~
一 引子
数据类型是用来记录事物状态的，而事物的状态是不断变化的(如:一个人年龄的增长（操作int类型） ，单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等)，这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率， python针对这些常用的操作，为每一种数据类型内置了一系列方法。本章的主题就是带大家详细了解下它们，以及每种数据类型的详细定义、类型转换。
二 数字类型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 类型转换
1、数据类型转换# 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错>>> s = \’123\’>>> res = int(s)>>> res,type(res)
(123, <class\’int\’>)>>>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 float同样可以用来做数据类型的转换>>> s = \’12.3\’>>> res=float(s)>>> res,type(res)
(12.3, <class\’float\’>)
2.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>>> type(str((1,2,3))) # tuple->str>>> type(str({1,2,3,4})) # set->str
3.3 使用
3.3.1 优先掌握的操作
str1 = \’hello python!\’# 1.按索引取值(正向取，反向取)：# 1.1 正向取(从左往右)>>> str1[6]
p# 1.2 反向取(负号表示从右往左)>>> str1[-4]
h# 1.3 对于str来说，只能按照索引取值，不能改>>> str1[0]=\’H\’ # 报错TypeError# 2.切片(顾头不顾尾，步长)# 2.1 顾头不顾尾：取出索引为0到8的所有字符>>> str1[0:9]
hello pyt# 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符>>> str1[0:9:2]
hlopt # 2.3 反向切片>>> str1[::-1] # -1表示从右往左依次取值!nohtyp olleh# 3.长度len# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)>>> len(str1) # 空格也算字符13# 4.成员运算 in 和 not in # 4.1 int:判断hello 是否在 str1里面>>> \’hello\’ in str1 True# 4.2 not in:判断tony 是否不在 str1里面>>> \’tony\’ not in str1 True# 5.strip移除字符串首尾指定的字符(默认移除空格)# 5.1 括号内不指定字符，默认移除首尾空格>>> str1 = \’ life is short! \’>>> str1.strip()
life is short!# 5.2 括号内指定字符，移除首尾指定的字符>>> str2 = \’tony\’ >>> str2.strip(\’*\’)
tony# 6.切分split# 6.1 括号内不指定字符，默认以空格作为切分符号>>> str3=\’hello world\’>>> str3.split()
[\’hello\’, \’world\’]# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串>>> str4 = \’127.0.0.1\’>>> str4.split(\’.\’)
[\’127\’, \’0\’, \’0\’, \’1\’] # 注意:split切割得到的结果是列表数据类型# 7.循环>>> str5 = \’今天你好吗？\’>>> for line in str5: # 依次取出字符串中每一个字符… print(line)
…
今
天
你
好
吗
？
3.3.2 需要掌握的操作
1.strip, lstrip, rstrip
str1 = \’tony**\’>>> str1.strip(\’\’) # 移除左右两边的指定字符\’tony\’>>> str1.lstrip(\’\’) # 只移除左边的指定字符tony>>> str1.rstrip(\’*\’) # 只移除右边的指定字符**tony
2.lower(),upper()
str2 = \’My nAme is tonY！\’>>> str2.lower() # 将英文字符串全部变小写my name is tony！>>> str2.upper() # 将英文字符串全部变大写MY NAME IS TONY！
3.startswith,endswith
str3 = \’tony jam\’# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False>>> str3.startswith(\’t\’) True>>> str3.startswith(\’j\’)False# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False>>> str3.endswith(\’jam\’)True>>> str3.endswith(\’tony\’) False
4.格式化输出之format
之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式
案例：
format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}>>> str4 = \’my name is {name}, my age is {age}!\’.format(age=18,name=\’tony\’)>>> str4 \’my name is tony, my age is 18!\’>>> str4 = \’my name is {name}{name}{name}, my age is {name}!\’.format(name=\’tony\’, age=18)>>> str4 \’my name is tonytonytony, my age is tony!\’
format的其他使用方式（了解）
类似于%s的用法，传入的值会按照位置与{}一一对应>>> str4 = \’my name is {}, my age is {}!\’.format(\’tony\’, 18)>>> str4
my name is tony, my age is 18!
把format传入的多个值当作一个列表，然后用{索引}取值>>> str4 = \’my name is {0}, my age is {1}!\’.format(\’tony\’, 18)>>> str4
my name is tony, my age is 18!>>> str4 = \’my name is {1}, my age is {0}!\’.format(\’tony\’, 18)>>> str4
my name is 18, my age is tony!>>> str4 = \’my name is {1}, my age is {1}!\’.format(\’tony\’, 18)>>> str4
my name is 18, my age is 18!
5.split,rsplit
split会按照从左到右的顺序对字符串进行切分，可以指定切割次数>>> str5=\’C:/a/b/c/d.txt\’>>> str5.split(\’/\’,1)
[\’C:\’, \’a/b/c/d.txt\’] # rsplit刚好与split相反，从右往左切割，可以指定切割次数>>> str5=\’a|b|c\’>>> str5.rsplit(\’|\’,1)
[\’a|b\’, \’c\’]
6.join
从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串>>> \’%\’.join(\’hello\’) # 从字符串\’hello\’中取出多个字符串，然后按照%作为分隔符号进行拼接\’h%e%l%l%o\’>>> \’|\’.join([\’tony\’,\’18\’,\’read\’]) # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接\’tony|18|read\’
7.replace
用新的字符替换字符串中旧的字符>>> str7 = \’my name is tony, my age is 18!\’ # 将tony的年龄由18岁改成73岁>>> str7 = str7.replace(\’18\’, \’73\’) # 语法:replace(\’旧内容\’, \’新内容\’)>>> str7
my name is tony, my age is 73!# 可以指定修改的个数>>> str7 = \’my name is tony, my age is 18!\’>>> str7 = str7.replace(\’my\’, \’MY\’,1) # 只把一个my改为MY>>> str7\’MY name is tony, my age is 18!\’
8.isdigit
判断字符串是否是纯数字组成，返回结果为True或False>>> str8 = \’5201314\’>>> str8.isdigit()True>>> str8 = \’123g123\’>>> str8.isdigit()False
3.3.3 了解操作
1.find,rfind,index,rindex,count# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1>>> msg=\’tony say hello\’>>> msg.find(\’o\’,1,3) # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引1 # 1.2 index:同find,但在找不到时会报错>>> msg.index(\’e\’,2,4) # 报错ValueError# 1.3 rfind与rindex：略# 1.4 count:统计字符串在大字符串中出现的次数>>> msg = "hello everyone">>> msg.count(\’e\’) # 统计字符串e出现的次数4>>> msg.count(\’e\’,1,6) # 字符串e在索引1~5范围内出现的次数1# 2.center,ljust,rjust,zfill>>> name=\’tony\’>>> name.center(30,\’-\’) # 总宽度为30，字符串居中显示，不够用-填充————-tony————->>> name.ljust(30,\’\’) # 总宽度为30，字符串左对齐显示，不够用填充tony**>>> name.rjust(30,\’\’) # 总宽度为30，字符串右对齐显示，不够用填充**tony>>> name.zfill(50) # 总宽度为50，字符串右对齐显示，不够用0填充0000000000000000000000000000000000000000000000tony# 3.expandtabs>>> name = \’tony\\thello\’ # \\t表示制表符(tab键)>>> name
tony hello>>> name.expandtabs(1) # 修改\\t制表符代表的空格数tony hello# 4.captalize,swapcase,title# 4.1 captalize：首字母大写>>> message = \’hello everyone nice to meet you!\’>>> message.capitalize()
Hello everyone nice to meet you! # 4.2 swapcase：大小写翻转>>> message1 = \’Hi girl, I want make friends with you!\’>>> message1.swapcase()
hI GIRL, i WANT MAKE FRIENDS WITH YOU! #4.3 title：每个单词的首字母大写>>> msg = \’dear my friend i miss you very much\’>>> msg.title()
Dear My Friend I Miss You Very Much # 5.is数字系列#在python3中num1 = b\’4\’ #bytesnum2 = u\’4\’ #unicode,python3中无需加u就是unicodenum3 = \’四\’ #中文数字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 = \’tony123\’>>> name.isalnum() #字符串中既可以包含数字也可以包含字母True>>> name.isalpha() #字符串中只包含字母False>>> name.isidentifier()True>>> name.islower() # 字符串是否是纯小写True>>> name.isupper() # 字符串是8000否是纯大写False>>> name.isspace() # 字符串是否全是空格False>>> name.istitle() # 字符串中的单词首字母是否都是大写False
四 列表
4.1 定义
定义：在[]内,用逗号分隔开多个任意数据类型的值l1 = [1,\’a\’,[1,2]] # 本质:l1 = list([1,\’a\’,[1,2]])
4.2 类型转换
但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中>>> list(\’wdad\’) # 结果：[\’w\’, \’d\’, \’a\’, \’d\’] >>> list([1,2,3]) # 结果：[1, 2, 3]>>> list({"name":"jason","age":18}) #结果：[\’name\’, \’age\’]>>> list((1,2,3)) # 结果：[1, 2, 3] >>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]
4.3 使用
4.3.1 优先掌握的操作
1.按索引存取值(正向存取+反向存取)：即可存也可以取 # 1.1 正向取(从左往右)>>> my_friends=[\’tony\’,\’jason\’,\’tom\’,4,5]>>> my_friends[0]
tony# 1.2 反向取(负号表示从右往左)>>> my_friends[-1] 5# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错>>> my_friends = [\’tony\’,\’jack\’,\’jason\’,4,5]>>> my_friends[1] = \’martthow\’>>> my_friends
[\’tony\’, \’martthow\’, \’jason\’, 4, 5]# 2.切片(顾头不顾尾，步长)# 2.1 顾头不顾尾：取出索引为0到3的元素>>> my_friends[0:4]
[\’tony\’, \’jason\’, \’tom\’, 4]# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素>>> my_friends[0:4:2]
[\’tony\’, \’tom\’]# 3.长度>>> len(my_friends)5# 4.成员运算in和not in>>> \’tony\’ in my_friendsTrue>>> \’xxx\’ not in my_friendsTrue# 5.添加# 5.1 append()列表尾部追加元素>>> l1 = [\’a\’,\’b\’,\’c\’]>>> l1.append(\’d\’)>>> l1
[\’a\’, \’b\’, \’c\’, \’d\’]# 5.2 extend()一次性在列表尾部添加多个元素>>> l1.extend([\’a\’,\’b\’,\’c\’])>>> l1
[\’a\’, \’b\’, \’c\’, \’d\’, \’a\’, \’b\’, \’c\’]# 5.3 insert()在指定位置插入元素>>> l1.insert(0,"first") # 0表示按索引位置插值>>> l1
[\’first\’, \’a\’, \’b\’, \’c\’, \’d\’, \’a\’, \’b\’, \’c\’]# 6.删除# 6.1 del>>> l = [11,22,33,44]>>> del l[2] # 删除索引为2的元素>>> l
[11,22,44]# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素>>> l = [11,22,33,22,44]>>> res=l.pop()>>> res44>>> res=l.pop(1)>>> res22# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值>>> l = [11,22,33,22,44]>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素>>> print(res)None# 7.reverse()颠倒列表内元素顺序>>> l = [11,22,33,44]>>> l.reverse() >>> l
[44,33,22,11]# 8.sort()给列表内所有元素排序# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错>>> l = [11,22,3,42,7,55]>>> l.sort()>>> l
[3, 7, 11, 22, 42, 55] # 默认从小到大排序>>> l = [11,22,3,42,7,55]>>> l.sort(reverse=True) # reverse用来指定是否跌倒排序，默认为False>>> l
[55, 42, 22, 11, 7, 3]# 8.2 了解知识：# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如>>> l1=[1,2,3]>>> l2=[2,]>>> l2 > l1True# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大>>> s1=\’abc\’>>> s2=\’az\’>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符\’z\’>\’b\’,所以s2>s1成立True# 所以我们也可以对下面这个列表排序>>> l = [\’A\’,\’z\’,\’adjk\’,\’hello\’,\’hea\’]>>> l.sort()>>> l
[\’A\’, \’adjk\’, \’hea\’, \’hello\’,\’z\’]# 9.循环# 循环遍历my_friends列表里面的值for line in my_friends:
print(line) \’tony\’\’jack\’\’jason\’45
4.3.2 了解操作
l=[1,2,3,4,5,6]>>> l[0:3:1]
[1, 2, 3] # 正向步长>>> l[2::-1]
[3, 2, 1] # 反向步长# 通过索引取值实现列表翻转>>> l[::-1]
[6, 5, 4, 3, 2, 1]
五 元组
5.1 作用
元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取
5.2 定义方式
在()内用逗号分隔开多个任意类型的值>>> countries = ("中国"，"美国"，"英国") # 本质:countries = tuple("中国"，"美国"，"英国")# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组>>> countries = ("中国"，) # 本质:countries = tuple("中国")
5.3 类型转换
但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型>>> tuple(\’wdad\’) # 结果：(\’w\’, \’d\’, \’a\’, \’d\’) >>> tuple([1,2,3]) # 结果：(1, 2, 3)>>> tuple({"name":"jason","age":18}) # 结果：(\’name\’, \’age\’)>>> tuple((1,2,3)) # 结果：(1, 2, 3)>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中
5.4 使用
tuple1 = (1, \’hhaha\’, 15000.00, 11, 22, 33) # 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！ >>> tuple1[0]1>>> tuple1[-2]22>>> tuple1[0] = \’hehe\’ # 报错：TypeError:# 2、切片(顾头不顾尾，步长)>>> tuple1[0:6:2]
(1, 15000.0, 22)# 3、长度>>> len(tuple1) 6# 4、成员运算 in 和 not in>>> \’hhaha\’ in tuple1 True>>> \’hhaha\’ not in tuple1 False # 5、循环>>> for line in tuple1:… print(line)1hhaha15000.0112233
六 字典
6.1 定义方式
定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能info={\’name\’:\’tony\’,\’age\’:18,\’sex\’:\’male\’} #本质info=dict({….})# 也可以这么定义字典info=dict(name=\’tony\’,age=18,sex=\’male\’) # info={\’age\’: 18, \’sex\’: \’male\’, \’name\’: \’tony\’}
6.2 类型转换
转换1: >>> info=dict([[\’name\’,\’tony\’],(\’age\’,18)])>>> info
{\’age\’: 18, \’name\’: \’tony\’}# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中>>> {}.fromkeys((\’name\’,\’age\’,\’sex\’),None)
{\’age\’: None, \’sex\’: None, \’name\’: None}
6.3 使用
6.3.1 优先掌握的操作
1、按key存取值：可存可取# 1.1 取>>> dic = {… \’name\’: \’xxx\’,… \’age\’: 18,… \’hobbies\’: [\’play game\’, \’basketball\’]… }>>> dic[\’name\’]\’xxx\’>>> dic[\’hobbies\’][1]\’basketball\’# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value>>> dic[\’gender\’] = \’male\’ >>> dic
{\’name\’: \’tony\’, \’age\’: 18, \’hobbies\’: [\’play game\’, \’basketball\’],\’gender\’:\’male\’}# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值>>> dic[\’name\’] = \’tony\’>>> dic
{\’name\’: \’tony\’, \’age\’: 18, \’hobbies\’: [\’play game\’, \’basketball\’]}# 2、长度len>>> len(dic) 3# 3、成员运算in和not in>>> \’name\’ in dic # 判断某个值是否是字典的keyTrue# 4、删除>>> dic.pop(\’name\’) # 通过指定字典的key来删除字典的键值对>>> dic
{\’age\’: 18, \’hobbies\’: [\’play game\’, \’basketball\’]}# 5、键keys()，值values()，键值对items()>>> dic = {\’age\’: 18, \’hobbies\’: [\’play game\’, \’basketball\’], \’name\’: \’xxx\’}# 获取字典所有的key>>> dic.keys()
dict_keys([\’name\’, \’age\’, \’hobbies\’])# 获取字典所有的value>>> dic.values()
dict_values([\’xxx\’, 18, [\’play game\’, \’basketball\’]])# 获取字典所有的键值对>>> dic.items()
dict_items([(\’name\’, \’xxx\’), (\’age\’, 18), (\’hobbies\’, [\’play game\’, \’basketball\’])])# 6、循环# 6.1 默认遍历的是字典的key>>> for key in dic:… print(key)… age
hobbies
name# 6.2 只遍历key>>> for key in dic.keys():… print(key)… age
hobbies
name# 6.3 只遍历value>>> for key in dic.values():… print(key)… 18[\’play game\’, \’basketball\’]
xxx# 6.4 遍历key与value>>> for key in dic.items():… print(key)… (\’age\’, 18)
(\’hobbies\’, [\’play game\’, \’basketball\’])
(\’name\’, \’xxx\’)
6.3.2 需要掌握的操作
1.get()
dic= {\’k1\’:\’jason\’,\’k2\’:\’Tony\’,\’k3\’:\’JY\’}>>> dic.get(\’k1\’)\’jason\’ # key存在，则获取key对应的value值>>> res=dic.get(\’xxx\’) # key不存在，不会报错而是默认返回None>>> print(res)None >>> res=dic.get(\’xxx\’,666) # key不存在时，可以设置默认返回的值>>> print(res)666 # ps:字典取值建议使用get方法
2.pop()
dic= {\’k1\’:\’jason\’,\’k2\’:\’Tony\’,\’k3\’:\’JY\’}>>> v = dic.pop(\’k2\’) # 删除指定的key对应的键值对,并返回值>>> dic
{\’k1\’: \’jason\’, \’kk2\’: \’JY\’}>>> v\’Tony\’
3.popitem()
dic= {\’k1\’:\’jason\’,\’k2\’:\’Tony\’,\’k3\’:\’JY\’}>>> item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回>>> dic
{\’k3\’: \’JY\’, \’k2\’: \’Tony\’}>>> item
(\’k1\’, \’jason\’)
4.update()
用新字典更新旧字典，有则修改，无则添加>>> dic= {\’k1\’:\’jason\’,\’k2\’:\’Tony\’,\’k3\’:\’JY\’}>>> dic.update({\’k1\’:\’JN\’,\’k4\’:\’xxx\’})>>> dic
{\’k1\’: \’JN\’, \’k3\’: \’JY\’, \’k2\’: \’Tony\’, \’k4\’: \’xxx\’}
5.fromkeys()
dic = dict.fromkeys([\’k1\’,\’k2\’,\’k3\’],[])>>> dic
{\’k1\’: [], \’k2\’: [], \’k3\’: []}
6.setdefault()
key不存在则新增键值对，并将新增的value返回>>> dic={\’k1\’:111,\’k2\’:222}>>> res=dic.setdefault(\’k3\’,333)>>> res333>>> dic # 字典中新增了键值对{\’k1\’: 111, \’k3\’: 333, \’k2\’: 222}# key存在则不做任何修改，并返回已存在key对应的value值>>> dic={\’k1\’:111,\’k2\’:222}>>> res=dic.setdefault(\’k1\’,666)>>> res111>>> dic # 字典不变{\’k1\’: 111, \’k2\’: 222}
七 集合
7.1 作用
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
7.2 定义
"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型2：集合内没有重复的元素3：集合内元素无序
"""s = {1,2,3,4} # 本质 s = set({1,2,3,4})# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?d = {} # 默认是空字典 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 关系运算
我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算
friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 >>> friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们
两个集合的关系如下图所示
1.合集(|)：求两个用户所有的好友（重复好友只留一个）>>> friends1 | friends2
{\’kevin\’, \’ricky\’, \’zero\’, \’jason\’, \’Jy\’, \’egon\’}# 2.交集(&)：求两个用户的共同好友>>> friends1 & friends2
{\’jason\’, \’egon\’}# 3.差集(-)：>>> friends1 – friends2 # 求用户1独有的好友{\’kevin\’, \’zero\’}>>> friends2 – friends1 # 求用户2独有的好友{\’ricky\’, \’Jy\’}# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）>>> friends1 ^ friends2
{\’kevin\’, \’zero\’, \’ricky\’, \’Jy\’}# 5.值是否相等(==)>>> friends1 == friends2False# 6.父集：一个集合是否包含另外一个集合# 6.1 包含则返回True>>> {1,2,3} > {1,2}True>>> {1,2,3} >= {1,2}True# 6.2 不存在包含关系，则返回True>>> {1,2,3} > {1,3,4,5}False>>> {1,2,3} >= {1,3,4,5}False# 7.子集>>> {1,2} < {1,2,3}True>>> {1,2} <= {1,2,3}True
7.4.2 去重
集合去重复有局限性
1. 只能针对不可变类型# 2. 集合本身是无序的，去重之后无法保留原来的顺序
示例如下
l=[\’a\’,\’b\’,1,\’a\’,\’a\’]>>> s=set(l)>>> s # 将列表转成了集合{\’b\’, \’a\’, 1}>>> l_new=list(s) # 再将集合转回列表>>> l_new
[\’b\’, \’a\’, 1] # 去除了重复，但是打乱了顺序# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如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_l=[]for dic in l:
if dic not in new_l:new_l.append(dic)
print(new_l)# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重[
{\'age\': 18, \'sex\': \'male\', \'name\': \'lili\'},{\'age\': 73, \'sex\': \'male\', \'name\': \'jack\'},{\'age\': 20, \'sex\': \'female\', \'name\': \'tom\'}
]
7.4.3 其他操作
1.长度>>> s={\’a\’,\’b\’,\’c\’}>>> len(s)3# 2.成员运算>>> \’c\’ in sTrue# 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. 求出没有同时这两门课程的学员名字集合
"""# 求出即报名python又报名linux课程的学员名字集合>>> pythons & linuxs# 求出所有报名的学生名字集合>>> pythons | linuxs# 求出只报名python课程的学员名字>>> pythons – linuxs# 求出没有同时这两门课程的学员名字集合>>> pythons ^ linuxs
八 可变类型与不可变类型
可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值
不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值
数字类型:
x = 10>>> id(x)1830448896 >>> x = 20>>> id(x)1830448928# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样
字符串
x = "Jy">>> id(x)938809263920 >>> x = "Ricky">>> id(x)938809264088# 内存地址改变了，说明字符串是不可变数据类型
列表
list1 = [\’tom\’,\’jack\’,\’egon\’]>>> id(list1)486316639176>>> list1[2] = \’kevin\’>>> id(list1)486316639176>>> list1.append(\’lili\’)>>> id(list1)486316639176# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型
元组
t1 = ("tom","jack",[1,2])>>> t1[0]=\’TOM\’ # 报错：TypeError>>> t1.append(\’lili\’) # 报错：TypeError# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改>>> t1 = ("tom","jack",[1,2])>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)>>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变>>> t1
(\’tom\’, \’jack\’, [111, 2])>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变(4327403152, 4327403072, 4327422472)
字典
dic = {\’name\’:\’egon\’,\’sex\’:\’male\’,\’age\’:18}>>> >>> id(dic)4327423112>>> dic[\’age\’]=19>>> dic
{\’age\’: 19, \’sex\’: \’male\’, \’name\’: \’egon\’}>>> id(dic)4327423112# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型
九 数据类型总结
