基本数据类型--数字
bool（布尔型）
只有两个值True和False，之所以将bool归类为数字，是因为我们习惯用1表示True，0表示False
int类型
Python中的整数属于int类型，默认用十进制表示，此外也支持二进制，八进制，十六进制表示方式
float（浮点数）
Python中的float（浮点数）就是数学中的小数（float是有限小数或无限循环小数），在运算中整数和浮点数运算的结果也是一个浮点数 一个浮点数的小数点位置是可变的，Python默认的小数精度是17位，也就是小数点后面16位，越往后越不准。其他语言也同样的问题。小数不精准是因为在转换成二进制的过程中会出现无线循环，在约省的时候就会出现偏差
基本数据类型--字符串
字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，''或'' ''或''' '''中间包含的内容称之为字符串，字符串只能存一个值，而且是不可变
PS：字符串比较特殊，虽然是不可变的，但是可以被迭代
字符串的操作
切片格式：s[start_index:end_index:strp]： 表示对变量s进行切片索引，start_index表示起始位置，end_index表示结束位置，strp则表示步长
PS:正向索引时候因为是从0开始，所以0-7显示的对应值其实就是0-6的值。参考索引位置
PS:反向索引是从1开始计数
按索引取值(正向取+反向取) ：只能取
s1="hello world"
s1[0] #索引0号位置的值
s1[-1] #反向索引第一个值
s1[-3] #反向索引第三个值
print(s1[-1:-4:-1]) #反向索引1-4的值
切片(顾头不顾尾从大字符串中切出一个子字符串)
例：顺序切片
s=abcdefghijklmn s[0:7:2] #则表示从0-7，步长2，就是从每两个位置取一个值,输出则是aceg
例：反转切片
s=abcdefghijklmn s[::-1] # 倒过来索引，其实就是把值反过来输出nmlkjihgfedcba
例：顺序切片
s=abcdefghijklmn s[::2] #则表示从开始到结束（len的长度范围呢），步长2，就是每两个位置取一个值,输出则是acegikm
例：反转切片
s=abcdefghijklmn s[::-1][0:7] # 先将s的值倒过来索引，然后输出0-6位置的值
例：反转切片
s=abcdefghijklmn s[:2][::-1] #先取前两位的值，再倒过来输出
PS：字符串的单引号和双引号都无法取消特殊字符的含义， 如果想让引号内所有字符均取消特殊意义，在引号前加r。 如name = r‘l hf’
PS:unicode字符串与r连用必须在r前面，如name=ur'l hf'
len(s1) #查看字符串的长度
成员运算in和not in:判断一个子字符串是否存在于一个大字符串中
msg='my name is alex,alex is dsb' #判断一个字符串是不是在另一个字符串中
print('alex' in msg)
print('egon' not in msg)
移除
移除空白strip: 移除字符串左右两边的字符 （lstrip和rstrip分别是移除左边和右边）
name=input('username>>>: ').strip() #这是一种操作，直接在input函数后面跟strip方法，移除用户输入的字符前后的空格,括号内可以指定一个
name=name.strip() #也可以这样重新赋值一次，如果在strip(' * ')括号内指定字符，则可以去除字符串前后被指定的字符，可以指定单个，也可以指定多个 print(msg.strip('*&^$/-?#='))
if name == 'egon':
print('认证成功')
切分
切分split: 把一個有規律的字符串按照某個字符進行切分,切成列表 # rsplit表示从右边开始
info='root:x:0:0::/root:/bin/bash'
res=info.split(':',maxsplit=-1) #如果maxsplit这个参数没有指定或者是-1，这时分割次数不会有限制
print(res)
info='' #将下列列表，换成：
userinfo=['root', 'x', '0', '0', '', '/root', '/bin/bash']
for item in userinfo: #即
item+=':'
info+=item
info=info.strip(':')
print(info,type(info))
#用join方法将 ‘，’换成‘：‘
userinfo=['root', 'x', '0', '0', '', '/root', '/bin/bash']
res=':'.join(userinfo)
循环
msg='hello'
for item in msg:
print(item)
讲字符串转换成小写或大写
lower() #将字符串全部变成小写，upper() #将字符串全部变成大写
x='ABBBBddd1231'
print(x.lower())
print('ABBBBddd2123'.upper())
查找指定字符开头或自定字符结尾的字符串
startswith() ,endswith() #satrtswith()括号内添加指定的值，就以这个指定的值查找相关开头的字符串，endswitch()括号内添加指定的值，就以这个指定的值查找相关开头的字符串
print('alex is sb'.startswith('alex'))
print('alex is sb'.startswith('al'))
print('alex is sb'.endswith('sb'))
格式化字符串传入参数
几种方式
msg='my name is %s my age is %s' %('egon',18) #这个利用占位符%来传入
msg='my name is {name} my age is {age}'.format(age=18,name='egon') #这个利用format()函数来传入
msg='my name is {} my age is {}'.format(18,'egon') #利用format传入，如果没有指定传入参数，那就按照位置传入，有点类似占位符%的原理
msg='my name is {0} my age is {0}{1}{1}'.format(18,'egon') #利用format传入，在想要传入值得位置写入数字，那就按照数字的排序对应format括号里值得位置排序传入
替换字符串内的某个值
msg='alex is alex hahahah alex'
res=msg.replace('alex','SB',1)
什么是列表
在[]内用逗号分隔，可以存放n个任意类型的值，而且可以被迭代
列表的定义：[]内已逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
students=['egon','alex','wupeiqi',]
用于标识：存储多个值的情况，比如一个人有多个爱好
列表的创建
list_test = ['张三'，'李四'，'alex']
#或
list_test = list('alex')
#或
list_test = list(['张三','李四','alex'])
列表的特点
特性：
1、可存放多个值
2、按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序的访问
3、可修改指定索引位置对应的值，可变，可迭代
列表嵌套和取值
存放多个学生的信息：姓名，年龄，爱好
students_info=[['egon',18,['play',]],['alex',18,['play','sleep']]]
students_info[0][2][0] #取出第一个学生的第一个爱好
列表常用操作
索引
names=['egon','alex','kevin']
print（name[0]） #索引0号位置的值
names[-1]=1000 #修改最后一个值
names[3]='aaaa' #修改3号位置的值
切片（顾头不顾尾，也包含步长）[num:num:num](start，end，step)
i = ['egon','alex','seven','yuan']
i[0:2] # 指输出从0开始到2的所有内容
i[:2] #由于没有指定开始位置，python会默认从0开始，所以指输出2前面所有的内容
i[2:] #指输出2后面所有的内容
i[:] #指输出所有的内容
i[::2] #由于没有指定开始和结束位置，所以python会默认从0开始到最后一个值，所以指每隔2个值提取一次
i[::-1] #指反向切片
列表的添加和删除
i.append('eva') #将一个值添加到列表的末尾
i.remove('eva') #从列表中删除一个值
i.pop() #在括号内添加指定数字，就可以删除列表指定位置的元素.括号内可以指定
del i[0] #用del方法直接删除指定位置的字符串
i.append('xxxx') #将括号内指定的字符添加至列表的末尾
i.insert(0,'chenwei') #在列表的任意位置添加内容，insert(位置，内容)
查看列表和判定列表中是否包含某个值
len(i) #查看列表的长度
'egon' in i #查看一个值是否包含在列表中，包含则返回True，反则False
i.count('egon') #查看指定元素在列表中出现的次数
i.index('egon')) #计算对象在列表中索引的位置
i.sort(reverse=True) #永久性的将列表按照顺序排列，reverse=true则表示相反，括号内不指定则默认reverse=False
i.reverse( ) #把列表元素相反打印,reversed()函数返回的是一个迭代器，而不是一个List，所以需要list函数转换一下.(参数可以是列表，元组，字符串，不改变原对象)
分割
>>>s = 'hello world'
>>>s.split(' ') 以空格为分隔符，分割字符串
>>>s.split(',') 以逗号为分隔符，分割字符串
PS：分隔符不限定，但是必须根据需求
连接
>>>i = ['hi','eva']
>>>'!'.join(i)
'hi!eva'
例 str = "-"
seq = ("a", "b", "c")
print str.join( seq )
a-b-c
PS:以逗号为分隔符，将字符串以' - '符号连接
什么是元组
与列表相似，列表用[]，元组是（）表示，元组相当于不可变的列表
如果存的多个值只有取的需求没有改的需求,用tuple最合适，占用内存最小
特性
1、可存放多个值，而且可存放数字、字符串，还可以存放更加复杂的数据类型
2、元组本身不可修改和改变，如果元组中包含其他可变元素，这些元素可改变
3、按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序的访问
创建元组
ages = (1,2,3,4,5,6)
#或
ages = tuple(1,2,3,4,5,6)
元组的常用操作
索引
>>>ages = (1,2.3,4,5,6)
>>>ages[0]
1
>>>ages[-1] #反过来索引，第一个位置
6
切片
同list
循环
for age in ages:
print(age)
长度
len（ages）
包含
1 in ages #包含返回True，反则返回False
什么是字典
在{}内用逗号分隔，可以存放多个key:value的值，value可以是任意类型
定义：info={'name':'egon','age':18,'sex':18} #info=dict({'name':'egon','age':18,'sex':18})
用于标识：存储多个值的情况，每个值都有唯一一个对应的key，可以更为方便高效地取值
字典是Python语言中唯一的映射类型
定义方式：{key1：value1，key2：value2}
1、键与值用冒号分开‘：’
2、项与项用逗号分开‘，’
字典特性：
1、key-value（键：值的结构）
2、key必须可hash，且必须为不可变数据类型，必须唯一
3、可存放任意多个值、可修改、可以不唯一
4、无序
字典的创建与常见操作
#字典的创建
person = {“name”:”alex”,”age”:20}
#或
person = dict(name='seven',age=20)
#或
person = dict({“name”:”egon”,'age':20})
#或
person = dict((['name','圆圆']，['文州'，18]))
注意：
>>>dic = {}.fromkeys(['k1','k2'],[]) #如果这里指定键但是不指定值，那么值的默认值就是空none
>>>dic {'k1':[],'k2':[]}
>>>dic['k1'].append(1)
>>>dic {'k1':[1],'k2':[1]}
字典的常见操作
键、值、键值对
1、dic.keys() 返回一个包含字典所有key的列表
2、dic.values() 返回一个包含字典所有value的列表
3、dic.items() 返回一个包含所有（键，值）元组的列表
4、dic.iteritems()、dic.iterkeys()、dic.itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表
新增
dic[key] = value
dic.update('xxx) #将括号中的所有元素添加到字典中，t可以是另一个集合，一个序列或者支持迭代的任意对象
{}.fromkeys(x,None) #fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值 ---Python的语法解释
查找
1、dic.setdefault(key,None) #查找字典中的key对应的值，如果字典中不存在key键，则新增这个键，默认None也可以指定，如果存在键则返回对应的值
2、dic.get(key(default=None)) #返回指定键的值，如果键不在字典中，返回一个指定值，默认为None，并不会添加
删除
1、dic.pop(key[,default])和get方法相似。如果字典中存在key，删除并返回key对应的value，如果key不存在，且没有给出default的值，则引发keyerror异常
2、dic.clear() 删除字典中的所有项或元素
3、del dic[key]
4、dic.popitem() #Python 字典 popitem() 方法随机返回并删除字典中的一对键和值。如果字典已经为空，却调用了此方法，就报出KeyError异常
修改
1、dic['key'] = 'new_value' 如果key在字典中存在，‘new_value’将会替代原来的value值
2、dic.update(dic2) 将字典dic2的键值对添加到字典dic中
dic={'name':'egon','age':18}
dic['age']=111 #如字典中存在，按照key来修改value的值
dic['sex']='male' #如字典中不存在则新增
查看
1、dic['key'] 返回字典中key对应的值，若key不存在字典中，则报错
2、dict.get(key,default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）
循环
1、for k in dic.keys() #遍历字典中所有的键
2、for k,v in dic.items() #遍历字典所有键，值
3、for v in dic.values() #遍历字典中所有的值
3、for k in dic #遍历整个字典
按顺序遍历字典中的所有键for k in sorted(dic.keys()),使用函数sorted（）来获得按特定顺序排列的键列表的副本
如果字典中值很多，最终输出的列表含大量的重复项，使用（set）集合来剔除，for x in set(dic.values())
长度
len(dic) #查看字典长度
#3、成员运算in和not in :判断的是key
# dic={'name':'egon','age':18}
# print(18 in dic)
# print('age' in dic)
字典的嵌套
info={
'name':'egon',
'hobbies':['play','sleep'],
'company_info':{
'name':'Oldboy',
'type':'education',
'emp_num':40,
}
}
print(info['company_info']['name']) #取公司名
students=[
{'name':'alex','age':38,'hobbies':['play','sleep']},
{'name':'egon','age':18,'hobbies':['read','sleep']},
{'name':'wupeiqi','age':58,'hobbies':['music','read','sleep']},
]
print(students[1]['hobbies'][1]) #取第二个学生的第二个爱好
字典、列表、元组的区别
字典用 { } 表示、列表用 [ ] 表示、元组用（） 表示
什么是集合
集合是一个数学概念：由一个或多个确定的元素所构成的整体叫做集合
集合中的元素有三个特征
1、确定性（元素必须可hash）
2、互异性（去重）
3、无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,4,5]算作同一个集合
PS：集合存在的意义就在于去重和关系运算
结合的用途
关系运算，去重
定义方式：在{}用逗号分割开多个元素,但是集合内元素的特点
去重的局限性:
被去重的元素必須是不可變類型
不能保證原來的顺序
in 和not in #判断某元素是否在集合内
==和!= #判断两个集合是否相等
PS：两个集合之间一般有三种关系，相交、包含、不想交。在Python中分别用下面的方法判断
set.isdisjoint(s): #判断两个集合是不是相交
set.issuperset(s): #判断集合是不是包含其他集合，等同于a>=b
set.issubset(s): #判断集合是不是被其他集合包含，等同于a<b
常用操作+内置的方法
长度 len(set)
合集（|）:取两个集合合并后的结果
A | B
A.union(B)
A.update(B)
交集（&）: 取两个集合共同的部分
A & B
A.intersection(B)
A.intersection_update(B) #用于移除两个或更多集合中都不重叠的元素，即计算交集， intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素
差集（-）: 取存在于左(右)边结合但不存在与右面集合的元素
A - B)
A.difference(B)
对称差集（^）:例如:取没有同时在A和B中的值
(A - B) | (B - A)
A ^ B
A.symmetric_difference(B)
关系运算
==
s1={1,2,3}
s2={3,2,1}
print(s1 == s2)
父集：>=
子集：<=
s1={1,2,3,4}
s2={1,2,3}
print(s1 >= s2)
print(s1.issuperset(s2)) #issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False
print(s2.issubset(s1)) #issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False
集合類型其他内置方法(**)
s1={'a','b','c'，‘d’}
print(s1.pop()) #随机弹出一个值，类似于删除
s1.discard('d') #discard() 方法用于移除指定的集合元素。该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会
s1.add('d')
print(s1)
s1={1,2,3}
s2={6,4,5}
print(s1.isdisjoint(s2)) #isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
列表、元组、字典、集合的区别
列表：用[ ]表示，可修改
元组：元组和列表在结构上没有什么区别，唯一的差异在于元组是只读的，不能修改。元组用“()”表示
字典：字典定义了键和值之间一对一的关系,但它们是以无序的方式储存的。定义 Dictionary 使用一对大(花)括号“{ }”
集合：是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.由于集合是无序的,所以，sets 不支持 索引, 分片, 或其它类序列（sequence-like）的操作
集合的常用操作
元素的增加 单个元素的增加add(),add的作用和类似列表中的append
对序列的增加update(),而update类似extend方法，update方法可以支持同时传入多个参数，传入时会把字符串拆分并无序排列
PS:由于集合有去重功能，所以update在传入多个参数时候会去除相同的参数,而数字是会顺序排列，字符串时随机排列
集合中元素的删除
元素的删除 set.discard(x) #从set中删除指定的元素x，如果x不在set中，无任何反应
set.remove(x) #从set中删除指定的元素x，如果x不在set中，则会报错Traceback
set.pop() #从set中随机删除一个元素，如果set为空，则会报错Traceback
set.clear() #将set中的所有元素清空
PS:可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典
PS: 不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间），如元组