初进python世界之数据类型
文章来源： https://www.cnblogs.com/seagullunix/articles/7297946.html
基本运算符
常用数据类型：
字符串（Str）
数字（Digit）
列表（List）
元组（Tuple）
集合（Set）
字典（Dict）
布尔（bool）
Python文件处理
基本运算符
当然，在讲数据类型之前，先了解一下Python的基本运算符：
运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算和位运算。以下分别学习每个运算符：
一、算数运算：
| 运算符 | 描述 | 实例 |
| + | 普通的加法运算 | 10+2=12 |
| - | 普通的减法运算 | 10-2=8 |
| * | 普通的乘法运算 | 10*2=20 |
| / | 普通的除法运算 | 10/2=5 |
| % | 取模运算，两数相除，取余数 | 10%2=0；10%3=1 |
| // | 取整除，两数相除，无论是否整除，只取商的整数部分，（没有四舍五入之说） | 10.0//2.0=5.0；10//3=3；18//3=6 |
| ** | 求幂运算，取一个数的幂次方 | 10**2=100 |
二、比较运算
说明： 以下比较的是两个对象的值。
| 运算符 | 描述 | 实例 |
| == | 等于，比较两个对象是否相等,返回True或者False | 如果a=10,b=10,那么a==b,返回True |
| != | 不等于，比较两个对象是否不相等,返回True或者False | 如果a=10,b=10,那么a!=b,返回False |
| <> | 不等于，比较两个对象是否不相等,返回True或者False，不常用 | 如果a=10,b=10,那么a<>b,返回False |
| > | 大于，比较a对象是否大于b对象,返回True或者False | 如果a=10,b=10,那么a>b,返回False |
| < | 小于，比较比较a对象是否小于b对象,返回True或者False | 如果a=10,b=10,那么a<b,返回False |
| >= | 大于等于，比较a对象是否大于等于b对象,返回True或者False | 如果a=10,b=10,那么a=>b,返回True |
| <= | 小于等于，比较a对象是否小于等于b对象,返回True或者False | 如果a=10,b=10,那么a<=b,返回True |
三、赋值运算
| 运算符 | 描述 | 实例 |
| = | 简单的赋值运算符，元素1赋值给元素2 | c=a+b,c=10+b等这些都属于简单的赋值运算 |
| += | 加法赋值运算符，先相加，再赋值，多用于循环语句中元素的自加 | c+=a相当于c=c+a |
| -= | 减法赋值运算符，先相减，再赋值，多用于循环语句中元素的自减 | c-=a相当于c=c-a |
| *= | 乘法赋值运算符，先相乘，再赋值，多用于循环语句中元素的自乘 | c*=a相当于c=c*a |
| /= | 除法赋值运算符，先相除，再赋值，多用于循环语句中元素的自除 | c/=a相当于c=c/a |
| %= | 取模赋值运算符，先取模，再赋值 | c%=a相当于c=c%a |
| **= | 取幂赋值运算符，先取幂，再赋值 | c**=a相当于c=c**a |
| //= | 取整除赋值运算符，先取整除，再赋值 | c//=a相当于c=c//a |
四、逻辑运算
| 运算符 | 描述 | 实例 |
| and | ‘与’，并且的意思，两边的元素都为真即返回真 | a and b：a为真，b为假，返回False，a为真，b为真 ，返回True |
| or | ‘或’，或者的意思，两边的元素只要有一个为真，即返回真 | a or b：a为真，b为假，返回True，a为假，b为假 ，返回False |
| not | ‘非’，相反的意思，如果是真的，返回假，如果是假的，返回真 | not a：a为真，返回False，a为假，返回True |
五、成员运算
| 运算符 | 描述 | 实例 |
| in | 在：如果对象a能在对象b中找到，则返回True，否则，返回False | x in y ;如果x在y中，则会返回True，否则为False |
| not in | 不在：如果对象a能在对象b中找不到，则返回True，否则，返回False | x not in y ;如果x不在y中，则会返回True，否则为False |
六、身份运算
说明只列出两个比较常用的，身份运算比较的是对象的name、id、value，以下比较的是两个对象的id（id相同，即type相同，值相同）
| 运算符 | 描述 | 实例 |
| is | 是：如果对象a和对象b的id相同，则返回True，否则，返回False | x is y ;如果x和y的id相同，则会返回True，否则为False |
| is not | 不是：如果对象a和对象b的id不相同，则返回True，否则，返回False | x is not y ;如果x和y的id不相同，则会返回True，否则为False |
七、位运算
比较二进制位，例如a=30,b=11 ，（转换二进制函数bin()）二进制表示就是a=11110,b=1011。位运算比较复杂，可以仅作了解。
| 运算符 | 描述 | 实例 |
| & | 按位与运算符：如果存在于两个对象中，则复制位到结果中。例如参与运算的两个值，从右到左进行比较，如果相应位都为1，则结果为1，只要有一个为0，结果即为0 | a&b,从右到左进行比较，结果即为1010，a比b多一位，a从左到右的第一位1在b的相应位置是空，即没有，则结果也是没有。 |
| | | 按位或运算符：只要存在于其中一个对象中，则复制位到结果中。例如参与运算的两个值，从右到左比较，如果相应位置中有一个是1，则结果为1 | a|b,从右到左进行比较，结果即为11111，同样a从左到右的第一位1在b的相应位置是空，即没有，但是结果仍然是1. |
| ^ | 按位异或运算符：如果对象对应的的二进位相异时，复制位。例如参与运算的两个值，从右到左进行比较，如果相应位不一样，即一个为0，一个为1，则结果为1。 | a^b,从右到左进行比较，结果即为10101，a比b多一位，a从左到右的第一位1在b的相应位置是空，结果相异，则为1。 |
| ~ | 按位取反运算符：一元的，具有翻转效果。例如参与运算的一个值，把相应位置的1变为0,0变为1 | ~a，结果即为-31，二进制为11111， 在一个有符号二进制数的补码形式 |
| << | 左移动运算符：左操作数的值由右操作数指定的位数左移。例如参与运算的两个值，左边的数的各二进制位全部左移，左移位数由右边的数值决定，高位丢弃，低位补0 | a<<b,结果1111000000000000，因为b=11，所以左移了11位，低位补0 |
| >> | 右移动运算符：左操作数的值由右操作数指定的位数右移。例如参与运算的两个值，左边的数的各二进制位全部右移，右移为数由右边的数值决定，高位丢弃，低位补0 |
a>>b,结果0，因为b=11，所以右移了11位，高位丢弃，另如果 b=3，则结果为11 |
常用数据类型
字符串（str）
字符串的声明有三种方式：单引号，双引号和三引号（三个单引号或者三个双引号）。不可变（可hash）
例如：
print('hello word!')
hello word!
print("hello word!")
hello word!
print('''hello word!''')
hello word!
print("""hello word!""")
hello word!
字符串根据索引的一些切片操作：
str = 'hello world!'
print(str) # 输出字符串
hello world!
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符（字符串具有顾头不顾尾的特性，所以不会取到最后一个字符）
hello world
print(str[0]) # 输出字符串第一个字符
h
print(str[2:5]) # 输出从第三个开始到第五个的字符
llo
print(str[2:]) # 输出从第三个开始后的所有字符
llo world!
print(str * 2) # 输出字符串两次
hello world!hello world!
print(str + "TEST") # 连接字符串
hello world!TEST
移除空格 strip,lstrip,rstrip
str=' hello world!'
sea='hello world!***'
print(str.strip()) #默认移除全部空格
hello world!
print(sea.strip('*')) #移除指定特殊字符*
hello world!
print(str.lstrip()) #默认移除左边空格
hello world!
print(sea.rstrip('*')) #移除右边指定特殊字符*
hello world!
切分 split,rsplit
str='root:x:0:0::/root:/bin/bash'
print(str.split()) #默认以空格为分隔符
['root:x:0:0::/root:/bin/bash']
print(str.split(':',1)) #以冒号为分隔符,只分割第一个冒号，默认分割全局
['root', 'x:0:0::/root:/bin/bash']
print(str.rsplit(':',2,))#从右边开始分割，分割从右边数的前两个冒号
['root:x:0:0:', '/root', '/bin/bash']
取字符串长度 len
str='hello world!'
print(len(str)) #取字符串的长度，等价于print(str.__len__())
12
print(str.__len__())
12
判断开头和结尾字符 startswith,endswith
str='seagull'
print(str.endswith('l')) #判断结尾，如果正确，则返回True，否则返回False
True
print(str.endswith('l',1,3)) #指定开头和结尾
False
print(str.startswith('s')) #判断开头，如果正确，则返回True，否则返回False
True
print(str.startswith('s',3,4)) ##指定开头和结尾
False
字符串的替换操作 replace
str='seagull'
print(str.replace('l','9')) #字符串的替换，将字母l替换为数字9，默认替换全局
seagu99
print(str.replace('l','9',1)) #字符串的替换，指定只将第一个找到的字母l替换为9
seagu9l
format的三种玩法
name='seagull'
age=18
hobby='eat'
print('我是%s，今年%s岁，爱好%s'%(name,age,hobby)) #%s的传参法
我是seagull，今年18岁，爱好eat
print('我是{}，今年{}岁，爱好{}'.format('seagull','18','eat')) #花括号传参，和%s有点相似
我是seagull，今年18岁，爱好eat
print('我是{}，今年{}岁，爱好'.format('seagull','18','eat')) #后面的传参可以比前面的花括号多，但是不能比前面的花括号少，否则会报错
我是seagull，今年18岁，爱好
print('我是{1}，今年{0}岁，爱好{0}'.format('seagull','18','eat')) #花括号里面写数字传参法，后面的参数默认指定了顺序 ，花括号里面可以写指定的数字镜像传参
我是18，今年seagull岁，爱好seagull
print('我是{name}，今年{age}岁，爱好{hobby}'.format(name='seagull',age='18',hobby='eat')) #指定参数，用一个等于号赋 值
我是seagull，今年18岁，爱好eat
查找和统计：find,rfind,index,rindex,count
str='seagull'
print(str.find('l')) #查找字符l的下标
5
print(str.find('b')) #查找字符b的下标,找不到返回-1
-1
print(str.index('l')) #查找字符l的下标
5
print(str.index('b')) #查找字符d的下标,找不到会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
print(str.rfind('l')) #从右边开始查找字符l的下标
6
print(str.rindex('l')) #从右边查找字符l的下标
6
print(str.count('l')) #统计字符串中包含字符的个数，可以指定范围查找
2
print(str.count('l',1,4)) #统计字符串中包含字符的个数
0
连接字符串 join （#可迭代对象必须都是字符串）
str=' ' #给tag赋值为空格
print(str.join(['seagull','is','looker'])) #插入字符，每个字符串之间以空格分割
seagull is looker
str='a' #给tag赋值为a
print(str.join(['seagull','is','looker'])) #插入字符，每个字符串之间以a分割
seagullaisalooker
str='9'
print(str.join(['seagull','is','looker'])) #插入字符，每个字符串之间以数字9分割
seagull9is9looker
str='9'
print(str.join(['seagull''is''looker'])) #插入字符，每个字符串之间没有分割
seagullislooker
str='seagull'
print(":".join(str)) #以冒号为分隔符，将字符串分割
s:e:a:g:u:l:l
显示打印 center,ljust,rjust,zfill
str='seagull'
print(str.center(30,'*')) #30个占位符，居中显示，字符不足时用*填充，默认是用空格填充
***********seagull************
print(str.ljust(10,'1')) #10个占位符，靠左显示，字符不足用数字1填充，默认空格
seagull111
print(str.rjust(10)) #10个占位符，靠右显示，字符不足默认空格填充，也可指定
seagull
print(str.zfill(10)) #10个占位符，靠右显示，字符不足用0填充,不能自己指定
000seagull
转换tab键为空格 expandtabs
str='sea\tgull'
print(str)
sea gull
print(str.expandtabs(1))
sea gull
字母大小写转换 lower ，upper ，captalize,swapcase,title
str='seaGULL'
print(str.lower())#将包含的大写字母转换成小写
print(str.upper())#将包含的小写字母转换成大写
str1='sea GULL'
str2='sea_Gull'
print(str1.capitalize()) #只首字母大写，其他的均小写
Sea gull
print(str2.capitalize())
Sea_gull
print(str1.swapcase()) #大小写翻转，大写变小写，小写变大写
SEA gull
print(str2.swapcase())
SEA_gULL
print(str1.title()) #标题，每个单词的首字母大写，其他的小写
Sea Gull
print(str2.title())
Sea_Gull
is数字系列（Python3），正确返回True，否则返回False
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
#isdigt:bytes,unicode，常用
... print(num1.isdigit())
True
print(num2.isdigit())
True
print(num3.isdigit())
False
print(num4.isdigit())
False
#isdecimal:uncicode
... #bytes类型无isdecimal方法
... print(num2.isdecimal())
True
print(num3.isdecimal())
False
print(num4.isdecimal())
False
#isnumberic:unicode,中文数字,罗马数字
... #bytes类型无isnumberic方法
... print(num2.isnumeric())
True
print(num3.isnumeric())
True
print(num4.isnumeric())
True
#浮点型不能判断
... num5='4.3'
num6='1/2'
print(num5.isdigit())
False
print(num5.isdecimal())
False
print(num5.isnumeric())
False
print(num6.isdigit())
False
print(num6.isdecimal())
False
print(num6.isnumeric())
False
is其他系列，正确返回True，否则为False
str1='seagull'
str2='seagu123'
print(str1.isalnum()) #判断字符串是否由只由字母和数字或者两者共同组成，是返回True，否则返回False
True
print(str2.isalnum())
True
print(str1.isalpha()) #判断字符串是否只由字母组成，是返回True，否则返回False
True
print(str2.isalpha())
False
str3='a'
str4='1'
print(str3.isidentifier())#判断单词是否为字母，或者是否包含关键字（字母，下划线），是就返回True
True
print(str4.isidentifier())#不能包含的有特殊字符（*，空格，=，数字等，）
False
str1='SEAGUll'
str2='seagu123'
print(str1.islower()) #判断包含的字母是否全部为小写字母，是就返回True
False
print(str2.islower())
True
str1='SEAGUll'
str2='SEAGULL123'
print(str1.isupper())#判断包含字母是否全部是大写，是就返回True
False
print(str2.isupper())
True
str1=' '
str2=''
print(str1.isspace())#判断是否为空格，是就返回True
True
print(str2.isspace())
False
str1='SEAGUll'
str2='Seagull123'
print(str1.istitle())#判断是否为标题（首字母是否大写，单词的首字母大写），如果是就返回True
False
print(str2.istitle())
True
字符串小练习
# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分）
name = " aleX"
# 1) 移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())
# 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果
print(name.startswith('al'))
# 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果
print(name.endswith('X'))
# 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l','p'))
# 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split('l'))
# 6) 将 name 变量对应的值变大写,并输出结果
print(name.upper())
# 7) 将 name 变量对应的值变小写,并输出结果
print(name.lower())
# 8) 请输出 name 变量对应的值的第 2 个字符?
print(name[1])
# 9) 请输出 name 变量对应的值的前 3 个字符?
print(name[0:3])
# 10) 请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])
# 11) 请输出 name 变量对应的值中 “e” 所在索引位置?
print(name.find('e'))
print(name.index('e'))
# 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
print(name[:-1])
print(name.rstrip('X'))
print(name.replace('X',''))
print(name.split('X')[0])
数字（Digit）
包括整数（int），浮点数（float），长整型（long） ，不可变（可hash）
删除数字对象引用
a=1
b=2
c=3
print(a)
1
del a
print(a) #被删除后再次打印就好报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
数字类型转换
int(x [,base]) #将x转换为一个整数
float(x ) # 将x转换到一个浮点数
complex(real [,imag]) #创建一个复数
str(x) #将对象x转换为字符串
repr(x) #将对象x转换为表达式字符串
eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) #将序列s转换为一个元组
list(s) #将序列s转换为一个列表
chr(x) #将一个整数转换为一个字符
unichr(x) #将一个整数转换为Unicode字符
ord(x) #将一个字符转换为它的整数值
hex(x) #将一个整数转换为一个十六进制字符串
oct(x) #将一个整数转换为一个八进制字符串
数字函数
abs(x) #返回数字的绝对值，如abs(-10) 返回 10
ceil(x) # 返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y) #如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) #返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) #返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) #返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) #如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) #返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...) # 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) #返回给定参数的最小值，参数可以为序列。
modf(x) #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x**y #运算后的值。
round(x [,n]) #返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) #返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
列表（List）
可以定义多个变量，有序的，可变（不可hash）类型，
索引
lis=['seagull',18,'eat']
print(lis[0])
seagull
lis=['seagull',18,'eat']
print(lis.index(18))
1
切片
lis=['seagull',18,'eat']
print(lis[:-1])
['seagull', 18]
追加
str=['seagull',18]
str.append('eat')
print(str)
['seagull', 18, 'eat']
str=['seagull',18]
str.extend('eat') #extend将引号里面的字符串分成单个字符，逐个添加，并且只能添加字符串
print(str)
['seagull', 18, 'e', 'a', 't']
str.extend(['sea','dongdong']) #如果添加列表，需要表明添加的是一个列表
print(str)
['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong']
str.extend({'hobby':'eat'}) #无法添加字典,但是可以将字典里面的冒号换成逗号添加多个列表
print(str)
['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby']
str.extend(('lele','honghong')) #小括号的形式添加列表
print(str)
['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong']
删除
str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong']
str.pop() #索引的方式删除列表数据，不指定默认从右到左开始删除
'honghong'
print(str)
['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele']
str.pop(0) #指定索引，删除指定删除项
'seagull'
print(str)
[18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele']
str.remove('hobby') #通过指定字符串的方式删除
print(str)
[18, 'e', 'a', 't', 'sea', 'dongdong', 'lele']
str=[] #清空列表
print(str)
[]
del str #删除列表
print(str)
<class 'str'>
长度
str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong']
print(len(str))
10
循环
str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong']
for index in range(len(str)): #根据列表的长度进行循环。range，指定范围循环
print(str[index])
# range(start,end,step)
# 参数含义：start：计数从start开始，默认从0开始。
# end：计数到end计数，但不包括end。
# step：每次跳跃的间距，默认为1
#循环输出结果：
seagull
18
e
a
t
sea
dongdong
hobby
lele
honghong
str = ['seagull', 'dongdong', 'hobby', 'lele', 'honghong']
for key,v in enumerate(str):
print(key,end='：')
print(v)
# enumerate()是python的内置函数
# enumerate在字典上是枚举、列举的意思
# 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
# enumerate多用于在for循环中得到计数
#得到的结果：
0：seagull
1：dongdong
2：hobby
3：lele
4：honghong
包含in
str = ['seagull', 'dongdong', 'hobby', 'lele', 'honghong']
if 'seagull' in str:
... print('ok')
...
ok
列表排序sort，sorted，reverse
#sort正向排序,直接修改源列表
a=[5,4,3,2,1]
a.sort()
print(a)
[1, 2, 3, 4, 5]
#sorted正向排序，可以保留源列表，生成新列表
... a=[5,4,3,2,1]
b=sorted(a)
print(b)
[1, 2, 3, 4, 5]
#sorted可以用在任何数据类型的序列中，返回的总是一个列表形式
... b=sorted('iplaypython.com**')
print(b)
['*', '*', '.', 'a', 'c', 'h', 'i', 'l', 'm', 'n', 'o', 'o', 'p', 'p', 't', 'y', 'y']
#reverse反转排序,直接修改源文件
... a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
a.reverse()
print(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1]
#reversed
a=[5,4,3,2,1]
for i in reversed(a):
print(i)
切片方式的逆转
mystring="54321"
mytuple=(5,4,3,2,1)
mylist=[5,4,3,2,1]
mystring[::-1]
'12345'
mytuple[::-1]
(1, 2, 3, 4, 5)
mylist[::-1]
[1, 2, 3, 4, 5]
小练习
# 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
# 模拟队列
# 模拟堆栈
data=['alex',49,[1900,3,18]]
sea={'name':data[0],'age':data[1],'data':data[2]}
print(sea)
元组（Tuple）
用来存储多个值，有序的，不可变（可哈希） 类型，可以当做字典的key值。
索引
sea=('seagull',18,'eat')
print(sea[0])
seagull
print(sea.index('seagull'))
0
切片
sea = ('seagull', 18, 'eat')
print(sea[:-1])
循环
sea = ('seagull', 18, 'eat')
for tuple in sea:
print(tuple)
长度
sea = ('seagull', 18, 'eat')
print(len(sea))
3
包含in
sea = ('seagull', 18, 'eat')
if 'seagull' in sea:
print('ok')
小练习
#简单购物车：实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入
#升级要求
# 要求用户输入总资产，例如：2000
# 显示商品列表，让用户根据序号选择商品，加入购物车
# 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
# 附加：可充值、某商品移除购物车
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
View Code
集合（Set）
去重，关系运算。无序，不可变（可hash）类型，可以作为字典的key，主要是不同的集合直接做关系运算。
存储 | 移除除
sea={'seagull','lele'}
sea.add('dongdong')
print(sea)
sea.pop() #任意删除
print(sea)
sea.remove('lele') #指定删除
print(sea)
in 和 not in
sea={'seagull','lele',18,'eat'}
if 'lele' in sea:
print('ok')
if 'dong' not in sea:
print('ok')
| 合集（union）
a={1,2,4,5,10}
b={3,4,7,8,10}
print(a|b)
{1, 2, 3, 4, 5, 7, 8, 10}
print(a.union(b))
{1, 2, 3, 4, 5, 7, 8, 10}
& 交集（intersection）
a={1,2,4,5,10}
b={3,4,7,8,10}
print(a&b)
{10, 4}
print(a.intersection(b))
{10, 4}
- 差集
a={1,2,4,5,10}
b={3,4,7,8,10}
print(a-b)
{1, 2, 5}
print(a.difference(b))
{1, 2, 5}
^ 对称差集
a={1,2,4,5,10}
b={3,4,7,8,10}
print(a^b)
{1, 2, 3, 5, 7, 8}
print(a.symmetric_difference(b))
{1, 2, 3, 5, 7, 8}
== 判断两个集合是否相等，返回布尔值
a={1,2,4,5,10}
b={3,4,7,8,10}
print(a==b)
False
>，>= ，<,<= 父集，子集（判断其中一个集合的元素是否均包含于另一个元素，返回布尔值）
a={1,2,3,4,5}
b={4,5}
print(a>b)
True
print(a>=b)
True
print(a.issuperset(b))#a是否包含于b
True
print(a<b)
False
print(a<=b)
False
print(a.issubset(b))
False
小练习：
# 一.关系运算
# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons&linuxs)
print(pythons.intersection(linuxs))
# 2. 求出所有报名的学生名字集合
print(pythons|linuxs)
print(pythons.union(linuxs))
# 3. 求出只报名python课程的学员名字
print(pythons-linuxs)
print(pythons.difference(linuxs))
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons^linuxs)
print(pythons.symmetric_difference(linuxs))
# 二.去重
#
# 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
l=['a','b',1,'a','a']
print(set(l))
# 2.在上题的基础上，保存列表原来的顺序
l=['a','b',1,'a','a']
sea=[]
for list in l:
if list not in sea:
sea.append(list)
print(sea)
#或者
l=['a','b',1,'a','a']
sea=[]
sea1=set()
for list in l:
if list not in sea:
sea1.add(list)
sea.append(list)
print(sea)
# 3.去除文件中重复的行，肯定要保持文件内容的顺序不变
import os
with open('sea.txt','r',encoding='utf-8') as read_f,\
open('.sea.txt.swap','w',encoding='utf-8') as write_f:
s=set()
for line in read_f:
if line not in s:
s.add(line)
write_f.write(line)
os.remove('sea.txt')
os.rename('.sea.txt.swap','sea.txt')
# 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
l=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'egon','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
]
sea=[]
for list in l:
if list not in sea:
sea.append(list)
print(sea)
#或者
s=set()
l1=[]
for item in l:
val=(item['name'],item['age'],item['sex'])
if val not in s:
s.add(val)
l1.append(item)
print(l1)
字典（Dict）
存储多个值，存在key值和value值，可变（不可hash）类型，需要注意的是，字典的key值是不可变的。
存/取
sea={}
sea['name']='seagull'
print(sea)
print(sea['name'])
删除
sea={'name':'seagull','age':18,'hobby':'eat'}
sea.pop('name')
'seagull'
print(sea)
{'age': 18, 'hobby': 'eat'}
长度
sea={'name':'seagull','age':18,'hobby':'eat'}
print(len(sea))
3
循环
sea={'name':'seagull','age':18,'hobby':'eat'}
for key in sea:
print(key)
for values in sea.values():
print(values)
for item in sea.items():
print(item)
小练习
# 1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。（2分）
#
# 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
sea1=[11,22,33,44,55,66,77,88,99,90]
sea2={'key1':[],'key2':[]}
for list in sea1:
if list > 66:
sea2['key1'].append(list)
elif list < 66:
sea2['key2'].append(list)
else:
continue
print(sea2)
# 2 统计s='hello alex alex say hello sb sb'中每个单词的个数
#
# 结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
s='hello alex alex say hello sb sb'
sea={}
for dic in s.split():
if dic in sea:
sea[dic]+=1
else:
sea[dic]=1
print(sea)
布尔（bool）
布尔型只有两个值，True或者False
你能够将Ture和False看作是预定义的设置为整数1和整数0的变量
True +4
5
a=True
a
True
True == 1
True
False == 0
True
Python文件处理
python中对文件、文件夹（文件操作函数）的操作需要涉及到os模块和shutil模块。
得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()
返回指定目录下的所有文件和目录名:os.listdir()
函数用来删除一个文件:os.remove()
删除多个目录：os.removedirs（r“c：\python”）
检验给出的路径是否是一个文件：os.path.isfile()
检验给出的路径是否是一个目录：os.path.isdir()
判断是否是绝对路径：os.path.isabs()
检验给出的路径是否真地存:os.path.exists()
返回一个路径的目录名和文件名:os.path.split() eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt')
分离扩展名：os.path.splitext()
获取路径名：os.path.dirname()
获取文件名：os.path.basename()
运行shell命令: os.system()
读取和设置环境变量:os.getenv() 与os.putenv()
给出当前平台使用的行终止符:os.linesep Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'
指示你正在使用的平台：os.name 对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'
重命名：os.rename（old， new）
创建多级目录：os.makedirs（r“c：\python\test”）
创建单个目录：os.mkdir（“test”）
获取文件属性：os.stat（file）
修改文件权限与时间戳：os.chmod（file）
终止当前进程：os.exit（）
获取文件大小：os.path.getsize（filename）
文件操作
os.mknod("test.txt") 创建空文件
fp = open("test.txt",w) 直接打开一个文件，如果文件不存在则创建文件
关于open 模式：
w 以写方式打开，
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
fp.read([size]) #size为读取的长度，以byte为单位
fp.readline([size]) #读一行，如果定义了size，有可能返回的只是一行的一部分
fp.readlines([size]) #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
fp.write(str) #把str写到文件中，write()并不会在str后加上一个换行符
fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
fp.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。 如果一个文件在关闭后还对其进行操作会产生ValueError
fp.flush() #把缓冲区的内容写入硬盘
fp.fileno() #返回一个长整型的”文件标签“
fp.isatty() #文件是否是一个终端设备文件（unix系统中的）
fp.tell() #返回文件操作标记的当前位置，以文件的开头为原点
fp.next() #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
fp.truncate([size]) #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。
目录操作
os.mkdir("file") 创建目录
复制文件：
shutil.copyfile("oldfile","newfile") oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile") oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
复制文件夹：
shutil.copytree("olddir","newdir") olddir和newdir都只能是目录，且newdir必须不存在
重命名文件（目录）
os.rename("oldname","newname") 文件或目录都是使用这条命令
移动文件（目录）
shutil.move("oldpos","newpos")
删除文件
os.remove("file")
删除目录
os.rmdir("dir")只能删除空目录
shutil.rmtree("dir") 空目录、有内容的目录都可以删
转换目录
os.chdir("path") 换路径
实例小练习
# 文件a.txt内容：每一行内容分别为商品名字，价钱，个数，求出本次购物花费的总钱数
# apple 10 3
# tesla 100000 1
# mac 3000 2
# lenovo 30000 3
# chicken 10 3
import fileinput
count=0
file=fileinput.input('sea.txt')
print('本次购买的商品信息：')
for content in file:
print(content,end="")
content=list(content.split())
count=int(content[1]) * int(content[2])+count
price=count
print('\n商品总额是：{}'.format(price))
# 修改文件内容，把文件中的alex都替换成SB
# i am seagull,
# seagull is a looker.
# and alex is a killer.
with open('sea.txt','r') as r:
lines=r.readlines() #按行读取文件
with open('sea.txt','w') as w:
for l in lines:
w.write(l.replace('alex','sb'))
忘羡一
