各种数据类型01 python2、3的区别
一、python2 与 python3 的区别
1.与用户交互
python2 ：input(">>:")一定要声明你输入的类型
python3 ： input() 接受用户的输入，无论用户输入的是什么类型，最终返回的一定是字符串
注：在python2 中 raw_input(">>:") 和python3 的input() 是一样的，无论用户输入的是什么类型，最终返回的一定是字符串
eg ：python2
>>> input(">>:") >>:sean Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<string>", line 1, in <module> NameError: name 'sean' is not defined >>> input(">>:") >>:"sean" 'sean' >>> input(">>:") >>:1 1 >>> input(">>:") >>:[1,2] [1, 2] >>> ------------------------------- >>> raw_input(">>:") >>:sean 'sean' >>> raw_input(">>:") >>:12 '12'
2. Python2 中有 int型（整型） 和 long型（长整型）。在区间[-24xxxxxxxxxxx,24xxxxxxxxxx] 的 整数是 int型。超过这个区间的称为 long型
python3中 无论整数有多大，都叫int型（整型）。没有long型（长整型）
3 . python2 和 python3 中的 str 数据类型本质区别：
python2 中 str 数据类型的本质是 8个bit位的序列
python3 中 str 数据类型的本质是unicode的序列
4. Python2中分为新式类（继承objectd的类）和经典类（没有继承object的类）
python3中都是新式类
5.python2中range:里面存的就是一个列表
python3中range:像一个老母鸡
二、基本数据类型
int型
float型
str型
list
dict
tuple
set
1.str型 (字符串)：
字符串是一个有序的字符的集合，用于存储、表示基本的文本信息。
*创建：' ' 或 " " 或 """ """
* 对字符串常用的操作：
s = 'hello,world'
01.索引字符 : s[1] ,s[-1]
02.切片 : s[0:7] 或 s[:7] ,s[2:6] ,s[7:] ,s[:] ,s[0:7:2] 2表示步长 。s[0:7:-1] - 表示方向，1表示步长。s[::2] ,s[::-2]
03.查找顺序 ：s.find('e') 结果为： 1
s.find('e',(1,6)) 表示查找当前字符串中某个元素的位置，返回索引。找不到就返回 -1
s = ' hello,word '
04. 移除空白 ：s.strip() 表示去除字符串 左和右部 的空格或者特殊字符
s.lstrip() 表示去除字符串 左部 的空格或者特殊字符
s.rstrip() 表示去除字符串 右部 的空格或者特殊字符
05.替换 :s.replace('h','H') 表示替换字符串里的元素
06.遍历循环 ：
07. 切分 ： s.split('填切分符'，2) 表示 对字符串进行分隔，可以指定切分的分隔符，返回一个列表
08. s.upper( ) 表示 使得字符串里的元素全部变成大写
09. s.lower( ) 表示 使得字符串里的元素全部变成小写
10. s.isdigit( ) 表示 判断当前字符串中的数据是不是一个数字，返回布尔值
11. s.count( ) 表示 统计当前字符串中某个元素的个数
12 s.title( ) 表示 使得字符串中每个单词首字母大写
2.list (列表):
可以存放各种数据类型，以逗号分隔，每个位置代表一个元素。
* 创建：用[ ] 或 list() 或 list([ ])
l0 = [1, 2, 3, 4, 5] l2 = list('12345') l1 = list([1,2,3,4,5]) print(l0) print(l1) print(l2) 结果： [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] ['1', '2', '3', '4', '5']
* 对列表常用的操作：
test = ['你好' , 'hello' , 'him' , '1234' , 'and' , '1']
01.索引 : test[3]
02.切片: test[0:4] 或 test[:4] ,test[2:5] ,test[4:] ,test[:] ,test[0:4:2] 2表示步长 。test[0:4:-1] - 表示方向，1表示步长。test[::2] ,test[::-2]
03.追加 : test.append('大大') 表示 追加，只能添加在列表的最后，一次只能添加一个值
04.删除 : test.remove('hello') 表示删除，指定删除，一次删一个。若有多个相同的元素，则是删除第一个。
05. 插入： test.insert( 填要插入的位置 , 要插入的值) 表示 插入，是通过索引指定插入 ,8
06. 添加： test.extend( [6,7,8]) 表示追加，要用列表参数，一次添加多个元素。
07.pop删除: test.pop(2) 表示指定索引删值，不填数字，则是默认从最后一个开始删，一次删除一个。print时，有返回所删除的值
08.遍历循环 : for i in tes
09. 获取元素：test.index 表示取列表中的某个元素
10.顺序排：test.sort( ) 表示在原列表上进行排序操作（可排序列表中的 数字，字母，汉字）
11 倒序排：test.sort(reverse=True) 表示在原列表上进行排序操作（可排序列表中的 数字，字母，汉字）
12.顺序排：sorted(test) 表示在新列表上对原列表进行排序操作，这时需要赋值给一个变量（可排序列表中的 数字，字母，汉字）
13 倒序排：sorted(test,reverse=True) 表示在原列表上进行排序操作，这时需要赋值给一个变量（可排序列表中的 数字，字母，汉字）
例子：12和13
l3=[1,5,7,2] l4=sorted(l3,reverse=True) print(l4)
14.清空： test.clear( )
3.dict (字典)
字典是python语言中唯一的映射关系
* 创建：用{ } 实质是 dict({ }) 或 dict() 或 {}.fromkeys(['k1','k2','k3'],[2]) key(键)：vaule(值) 这称为键值对，也称为一个项
l0 = {'name':'小红', 'age':18, '爱好':'game'}
l1 = dict(name='小红', age=18, 爱好='game')
print(l0)
print(l1)
结果：
{'name': '小红', 'age': 18, '爱好': 'game'}
{'name': '小红', 'age': 18, '爱好': 'game'}
l1 = {}.fromkeys(['k1','k2','k3'],2)
l2 = {}.fromkeys(['k1','k2','k3'],[2])
l3 = {}.fromkeys(['k1','k2','k3'],[2,3])
l4 = {}.fromkeys(['k1','k2','k3'],'hello')
l5 = {}.fromkeys(['k1','k2','k3'],{2,3,4})
l6 = {}.fromkeys(['k1','k2','k3'],1.4)
l7 = {}.fromkeys(['k1','k2','k3'],(1,4))
print(l1)
print(l2)
print(l3)
print(l4)
print(l5)
print(l6)
print(l7)
结果：
{'k1': 2, 'k2': 2, 'k3': 2}
{'k1': [2], 'k2': [2], 'k3': [2]}
{'k1': [2, 3], 'k2': [2, 3], 'k3': [2, 3]}
{'k1': 'hello', 'k2': 'hello', 'k3': 'hello'}
{'k1': {2, 3, 4}, 'k2': {2, 3, 4}, 'k3': {2, 3, 4}}
{'k1': 1.4, 'k2': 1.4, 'k3': 1.4}
{'k1': (1, 4), 'k2': (1, 4), 'k3': (1, 4)}
l0 = {}.fromkeys(['k1','k2','k3'],[])
l2 = {}.fromkeys('123',[])
l3= {}.fromkeys('123',9)
l4= {}.fromkeys('123',())
l2['1'].append(6)
print(l0)
print(l2)
print(l3)
print(l4)
结果：
{'k1': [], 'k2': [], 'k3': []}
{'1': [6], '2': [6], '3': [6]}
{'1': 9, '2': 9, '3': 9}
{'1': (), '2': (), '3': ()}
* 对字典常用的操作：
01. 查看
person = {'name': '李丹', "age": 25, "爱好": 'game'}
.keys() 表示返回一个包含所有key的列表
d={'r': 4, 'e': 5, 'f': 6}
print(d.keys()) # dict_keys(['r', 'e', 'f'])
print(type(d.keys())) # <class 'dict_keys'> 说明d.keys()是一个字典对象
for i in d.keys(): # d.keys() 是一个字典对象,可以遍历
print(i)
person['填要查看的值 所对的键'] 表示查看某个值
.vaules() 表示返回一个包含所有vaule的列表
.items() 表示返回一个包含元组（key,vaule）的列表
.get('key') 表示查看键 获取指定key的值，如果值不存在·，默认返回None,可以通过第二个参数修改默认返回的内容
get 获取指定key的值，如果值不存在·，默认返回None,可以通过第二个参数修改默认返回的内容 dic = {'1': 1, '2':1, '3': 3} dic.get('1') print(dic.get('1')) dic.get('8') # 如果值不存在·，默认返回None, print(dic.get('8')) 结果： 1 None dic = {'1': 1, '2':1, '3': 3} dic.get('8', 0) # 如果值不存在·，默认返回None,可以通过第二个参数修改默认返回的内容 print(dic.get('8', 0)) 结果： 0
02.新增 ： person['要加的key']='要加的vaule' eg: person['身高']='175cm' 表 示在字典的末尾追加
person.update(dic2) 将字典dic2的键值对添加到字典xx中 .若原字典中 有所添加的key，则会修改对应的值。如原字典中没有所添加的key,则会 添 加key和值
d=dict(name='sean',age=20) d.update({'name':'tank','aihao':'game'}) #形式一 print(d) 结果： {'name': 'tank', 'age': 20, 'aihao': 'game'}
d=dict(name='sean',age=20)
d.update(name='tank') #形式二
print(d)
结果
{'name': 'tank', 'age': 20}
d=dict(name='sean',age=20)
d.update(爱好='game') # 也是形式二
print(d)
结果：
{'name': 'sean', 'age': 20, '爱好': 'game'}
.setdefault（填要加的键和值） :key不存在新增键值对，返回 新增value，key存在返回对应的value 一次增加一个
dic = {'1': 1, '2':1, '3': 3}
dic.setdefault('1',8) # key存在返回对应的value
print(dic.setdefault('1',8)) # key存在返回对应的value
print(dic) # 因为key已存在 就不能添加key了
结果：
1
{'1': 1, '2': 1, '3': 3}
dic = {'1': 1, '2':1, '3': 3}
dic.setdefault('7',8) # key不存在新增键值对，返回新增value
print(dic.setdefault('7',8)) # key不存在新增键值对，返回新增value
print(dic) # 因为key不存在 就添加key了
结果：
8
{'1': 1, '2': 1, '3': 3, '7': 8}
03.删除：
person.clear() 删除字典中所有的项
.pop( ) 删除指定key的值，如果指定的key不存在·，默认返回None,可以通过 第二个参数修改默认返回的内容
dic = {'1': 1, '2':1, '3': 3}
dic.pop('8', 0) # 如果指定的key不存在·，默认返回None,可以通过第二个参数修改默认返回的内容
print(dic.pop('8', 0))
结果：
0
dic = {'1': 1, '2':1, '3': 3}
a=dic.pop('3') #指定key进行删除，返回为对应的value
print(a)
print(dic)
结果
3
{'1': 1, '2': 1}
.popitem() 表示 随机删除一个键值对，返回元组
dic = {'1': 1, '2':1, '3': 3}
print(dic.popitem()) #随机弹出一个键值对，有返回值，返回只是一个元组
结果：
（'3':3）
04. 修改 ： person['填要修改的值 对应的键']='新的值'
05.遍历循环 ： for k in person.keys() 遍历字典里的所有的键
print(k)
d1 = {'a':1, 'b':2, 'c':3}
for i in d1.keys():
print(i)
a
b
c
for k,v in person.items() 遍历字典里所有的项
print(k,v)
d1 = {'a':1, 'b':2, 'c':3}
for i, v in d1.items():
print(i,v)
a 1
b 2
c 3
for i in dic() 遍历字典dic
d1 = {'a':1, 'b':2, 'c':3}
for i in d1:
print(d1[i]) #表示 取字典里所有的键
print(i) #表示 取字典里所有的值
4.tuple(元组 )
和列表相似。但是不可变
*创建 ： 用（）实质是tuple( () ) 或 tuple()
l0 = (1,2,3) l1 = tuple('123') print(l0) print(l1) 结果： (1, 2, 3) ('1', '2', '3')
* 对元组常用的操作：
01.索引 类列表
02.切片 类列表
03.遍历循环 类列表
注意：定义只有一个元素的元组时，元素后面一定要加逗号，
t =(1,) 表示元组
t=(1) 表示数据是整型 t=1
t =('a',) 表示元组
t=('a') 表示字符串 t='a'
元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变
5.集合
定义时，也用{ }。但是d={ }默认的是空字典，d=set( )才是空集合
*创建 ： 用{ } 实质是set({}) 或 set( )
l0 = {1,2,3,4}
l1 = set('1234')
print(l0)
print(l1)
结果：
{1, 2, 3, 4}
{'4', '1', '3', '2'}
* 对集合常用的操作：
1.关系运算
01.求交集 & ， &=
a = {'张三', '李四', '王五', '赵六', 'python'}
b = {'张三', '李四', '小花', '小红', 'linux'}
c = a & b # 求交集
print(c)
print( a & b)
结果：
{'张三', '李四'}
{'张三', '李四'}
02.求并集 | ， |= ， union
a = {'张三', '李四', '王五', '赵六', 'python'}
b = {'张三', '李四', '小花', '小红', 'linux'}
d = a | b # 求并集
print(d)
print(a.union(b))
print(b.union(a))
结果：
{'小花', 'linux', '小红', '李四', '赵六', '张三', '王五', 'python'}
{'小花', 'linux', '小红', '李四', '赵六', '张三', '王五', 'python'}
{'小花', 'linux', '小红', '李四', '赵六', '张三', '王五', 'python'}
03.求差集 ^ ，^= ， symmetric_difference
a = {'张三', '李四', '王五', '赵六', 'python'}
b = {'张三', '李四', '小花', '小红', 'linux'}
e = a ^ b # 求差集
print(e)
print(a.symmetric_difference (b))
print(b.symmetric_difference (a))
结果：
{'赵六', 'python', 'linux', '小红', '小花', '王五'}
{'赵六', 'python', 'linux', '小红', '小花', '王五'}
{'赵六', 'python', 'linux', '小红', '王五', '小花'}
04.求一边多出的子集 - ， -= ， difference
a = {'张三', '李四', '王五', '赵六', 'python'}
b = {'张三', '李四', '小花', '小红', 'linux'}
f = a - b # 求a边多出来的集
g = b - a # 求b边多出来的集
print(f)
print(a.difference(b))
print(g)
print(b.difference(a))
结果：
{'赵六', '王五', 'python'}
{'赵六', '王五', 'python'}
{'linux', '小花', '小红'}
{'linux', '小花', '小红'
2.逻辑运算
01. isdisjoint 判断两个集合是不是 不相交。返回的是一个布尔值
a = {'张三', '李四', '王五', '赵六', 'python'}
b = {'张三', '李四', '小花', '小红', 'linux'}
print(a.isdisjoint(b)) # 判断两个集合是不是 不相交。返回的是一个布尔值
结果：False
02. issuperset 判断集合是不是 包含其他集合。既是 a>=b
a = {'张三', '李四', '王五', '赵六', 'python'}
b = {'张三', '李四', '小花', '小红', 'linux'}
print(a.issuperset(b)) # 判断集合是不是 包含其他集合。既是 a>=b
结果：
False
03. issubset 判断集合是不是 被其他集合包含。既是 a<=b
a = {'张三', '李四'}
b = {'张三', '李四', '小花', '小红', 'linux'}
print(a.issubset(b)) # 判断集合是不是 被其他集合包含。既是 a<=b
结果：
True
3. 元素的增加 .add() # 表示增加元素
.update() # 可一次添加多个元素
三、格式化输出
1. %s 表占位符，可以接受任意类型的数据
2. %d 表占位符，只接受数字
3 .format
三种形式：
01.必须一一对应（是指占位符的个数要与变量值个数一致）： print('{} {}'.format('a','b')) 结果：ab
02.指定传值（是指不会因为变量值的位置改变而变） ： print('{name} {age}'.format(age=12,name='hello'))
03. print('{0}{1}{0}'.format('a','b')) 注：0代表a 1代表b
4. f-string 既是f "{ } " { } 表示占位符
四、运算符
1.算数运算符：
//
%
**
2.增量赋值：
+=
-=
*=
/=
3.链式赋值：
x=y=z=1
4.交叉赋值：
a = 1
b = 2
a ,b = b, a
5.解压赋值：
l1 = [1,2,3]
a ,b ,c = l1
*_可以接收溢出的元素
6.逻辑运算符
and
or
not
浙公网安备 33010602011771号