初进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,
}

集合（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'))

忘羡一