Python-基础数据类型-类型转换-优先级

1.基础数据类型

数字类型、布尔值bool、字符串str、列表list、元组tuple、字典dict,集合等

2.运算符

• 结果为具体的值—>算数运算、赋值运算
• 结果为bool值 —>比较运算、逻辑运算、成员运算。

常用运算符优先级图示

① 算术运算（a=10 b=20）

② 赋值运算

③ 比较运算

幂运算易错点

	-3 ** 2              #  -(3×3)
	-9
	
	3 ** 2               #  +(3×3)
	9
	
	2 ** -2              #  (1/(2×2))
	0.25 

④ 逻辑运算

⑤ 成员运算

name = name = ['张三','李四','王五','孙六',['乔治','佩奇']]
# 用in 判断成员变量
		'王五' in name
		#输出 ：True
	# 访问列表中的列表
		'乔治' in name
		#输出 ：False
		'乔治' in name[4]
		#输出 ：True
# 用 not in 判断成员变量
		'玛卡巴卡' not in name
		#输出 ：True
	# 访问‘乔治’成员变量
		name[4][0]
		#输出 ：'乔治'

3.常用数据类型

1、数字类型（类型转换-查看类型）

1. python 数字类型有int整型、long长整型、float浮点数、complex复数、以及布尔值（0和1）
2. 在Python2中，整数的大小是有限制的，即当数字超过一定的范围不再是int类型，而是long长整型。而在Python3中，无论整数的大小长度为多少，统称为整型int。
3. 两种方法

3.1 将字符串数据类型转为int类型, 注：字符串内的内容必须是数字 , int转换成str

	#str→ int
 	a = "100"  
		#方法1：  
			a = int(a)
			print(a)
			print(type(a))
		#方法二
			print(type(eval(a)))

	#int→str
		a = 123
		b =str(a)
		b
		# 输出：'123'

3.2 float类型转换成int类型小数点前截取--效率高，float转成str

	#float→int
		a = 122.122
		b = int(a)
		b
		# 输出：122
	
	#float→str
		a= 123.1
		b= str(a)
		b
		# 输出：'123.1'

3.3 带科学计数法的类型转换

#正数
	a = 1.5e50
	b = str(a)
	b
	# 输出：'1.5e+50'              变+号

#负数
	a = 1.5e-50
	b = str(a)
	b
	'1.5e-50'             变-号

3.4 bit_length() -->将数字转换为二进制，并且返回最少位二进制的位数

	a= 100
	print(a.bit_length())
	# 输出：7

3.5 查看类型

1. type()
2. isinstance()

# type()
	a= 12
	print(type(a))
	# 输出：

# isinstance()
	a = 'ssss'
	isinstance(a,str)
	# 输出：True

2、布尔值 —>bool类

在编译器里写布尔值的时候首字母大写

• True == 1
• False == 0 == 空值 （None () [] {} 0 " " ' ' ）

	bool(())
	# 输出：False
	bool('')
	# 输出：False
	bool(0)
	# 输出：False

3、字符串 —>str类

• '单引号' "双引号"创建字符串
• 创建好的字符串是不可修改的

3.1 字符串的创建

	name = 'Big_Boos'
	print(name)

3.2 切片（截取字符串）

#获取切片，复数代表倒数第几个，从0开始
	print(name[0])
	# 输出：B
	print(name[0:-2])
	# 输出：Big_Bo

3.3 索引–>

1. index()
2. find()

• 在某一区间查找指定字符的索引
• 使用：成员变量.index(“查找的字符”, 起始点,结束点)
• 只返回第一个

	name = 'Big_Boos'
	name.index("B",1,5)
	# 输出：4

3.4 长度 -->len()

• len()方法–>同样可以用于其他数据类型，例如查看列表、元组以及字典中元素的多少。

	name = 'Big_Boos'
	print(len(name))
	# 输出：8

3.5 删除 --> del

	name = 'Big_Boos'
	del name
	print(name)
	# 输出：报错  NameError: name 'name' is not defined

3.6 判断字符串内容

1. 判断是否全是字母+数字：isalnum()
2. 判断是否全是数字：isdigit()
3. 判断是否全是字母：isalpha()

# 定义四个字符串变量
	aa = '123'
	bb = 'qwer'
	cc = '123qwe'
	dd = '123qwe$'
#判断是否全为数字
	aa.isdigit()
	# 输出：True
	aa.isalnum()
	# 输出：True
#判断是否全为字母
	bb.isalpha()
	# 输出：True
#判断是否全为数字或者字母
	cc.isalnum()
	# 输出：True
	dd.isalnum()
	# 输出：False

3.7 字符转大小写转换

1. capitalize()--------首字母转大写
2. lower()-------------全部转小写
3. upper()-------------全部转大写
4. title()----------------设置为标题
5. swapcase()-------大小写互相转换
6. encode(encoding=‘utf-8’，errors=‘strict’)–对字符串进行编码

name ="little_five"
#首字母大写-->capitalize
	name.capitalize()
	# 输出：'Little_five'

#转为标题-->title
	info ="my name is little_five"
	info.title()
	# 输出：'My Name Is Little_Five'

#全部转为小写-->lower
	name ="LITTLE_FIVE"
	name.lower()
	# 输出：'little_five'

#全部转为大写-->upper
	name = "little_five"
	name.upper()
	# 输出：'LITTLE_FIVE'

#大小写互相转换-->swapcase
	name ="lIttle_fIve"
	name.swapcase()
	# 输出：'LiTTLE_FiVE'

3.8 删除 --> del

	name = 'Big_Boos'
	del name
	print(name)
	# 输出：报错  NameError: name 'name' is not defined

3.9 判断以那个字符开头结尾

1. startswith()
2. endswith()

name ="little-five"
#判断以什么结尾
	name.endswith("e")
	# 输出：True
#判断以什么开头
	name.startswith("li")
	# 输出：True

3.10 格式化输出

1. format()--------------------根据变量名或索引号传值
2. format_map()------------根据字典的键值对传值

#forma方法
	#方式一：根据变量名传值
		info ="my name is {name},I'am {age} years old."
		info.format(name="little-five",age=22)
		# 输出："my name is little-five,I'am 22 years old."
	
	#方式二：根据索引号传值
		info ="my name is {0},I'am {1} years old."
		info.format("little-five",22)
		# 输出："my name is little-five,I'am 22 years old."
#format_map方法 : 根据键值对传值
	info ="my name is {name},I'am {age} years old."
	info.format_map({
     "name":"little-five","age":22})
	# 输出："my name is little-five,I'am 22 years old."

3.11 jion方法

• 将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串

#字符串
	name ="littefive"
	"-".join(name)
	# 输出：'l-i-t-t-e-f-i-v-e'

#列表
	info = ["xiaowu","say","hello","world"]
	"--".join(info)
	# 输出：'xiaowu--say--hello--world'

3.12 分割

1. split()-----------根据特殊标识将字符串分割成自定义几个部分并返回列表
2. partition()------根据特殊标识将字符串分割成三部分并返回列表
3. 注意：字符串中是中文的特殊标识符也必须是中文的，保持一致
4. 分割后的字符串可以直接附给容器(元组，列表等)

#partition ：只能将字符串分为三个部分，生成列表
	name ="little-five"
	name.partition("-")
	# 输出：('little', '-', 'five')

#split-->分割字符串，并且可以指定分割几次，并且返回列表
	name ="little-five-hello-world"
	name.split("-")
	# 输出：['little', 'five', 'hello', 'world']
	name.split("-",2)  #指定分割几次
	# 输出：['little', 'five', 'hello-world']
# 注意：特殊标识符与字符串保持一致
	str1 = '12：34'        # 中文冒号
	str1.split (':')       #英文冒号：未分割
	输出：['12：34']
	
	str1.split ('：')      #中文冒号：分割了
	输出：['12', '34']    

# 分割结果附给容器（元组）
	    str2 = '张三-教师' 
	    (name,roal) = str2.split ('-')
		(name,roal)
		输出：('张三', '教师') 

3.13 替代 -->replace

#替代
	name ="little-five"
	name.replace("l","L")
	# 输出：'LittLe-five'
	#也可以指定参数，替换几个
	name.replace("i","e",2)
	# 输出：'lettle-feve'

3.14 清除空白

1. strip()-----------------去除字符串左右两边的空格
2. lstrip()----------------去除字符串左边的空格
3. rstrip()----------------去除字符串右边的空格

name ="  little-five   "
	#去除字符串左右两边的空格
	name.strip()
	# 输出：'little-five'
	#去除字符串左边的空格
	name.lstrip()
	# 输出：'little-five   '
	#去除字符串右边的空格
	name.rstrip()
	# 输出：'  little-five'

3.15 替换 -->makestran 、translate

 待补充。。。

4、列表 —>list类

4.1 定义

1. 列表是由一系列特定元素顺序排列组成的
2. 它的元素可以是任何数据类型即数字、字符串、列表、元组、字典、布尔值等
3. 其元素也是可修改的。

4.2 创建列表简单实例：

#方式1
	person = ['name',20,('张三','李四'),False,[1,2,3],{
     'str',12},{
     'name':'zhang'}]
	print(person )
	# 输出：['name', 20, ('张三', '李四'), False, [1, 2, 3], {'str', 12},{'name':'zhang'}]
	print(person[6])
	# 输出：{'name': 'zhang'}
#方式2
	names = list(['name',20,('张三','李四'),False,[1,2,3],{
     'str',12},{
     'name':'zhang'}])
	names
	# 输出 ：['name', 20, ('张三', '李四'), False, [1, 2, 3], {'str', 12}, {'name': 'zhang'}]

4.3 索引、切片

• 索引:从左边是0开始，从右边是-1开始，（a,b）区间遵循左闭右开原则

# [ ：] 相当于复制列表
	name = ['张三', '张三', '李四', '王尔瓦兹']
	str1 = name[ : ]
	print(str1)
	# 输出：['张三', '张三', '李四', '王尔瓦兹']
 #索引：从左边是`0`开始，从右边是-1开始，（a,b）区间遵循左闭右开原则
	names = ["little-five","James","Alex"]
	print(names[0:-1])
	# 输出：['little-five', 'James']

 #切片-->单写[ : ]中的一个，左输出后边的，右输出前边的
	m1 =names[1:]
	print(m1)
	# 输出：['James', 'Alex']
	m2 =names[:-1]
	print(m2)
	# 输出：['little-five', 'James']

4.4 #追加元素–>append()

• 追加append（）：将元素作为一个整体添加（一次只添加一个）

	name =["xiaowu","little-five","James"]
	name.append("alex")
	print(name)
	# 输出：['xiaowu', 'little-five', 'James', 'alex']

4.5 extend() - 拓展

• extend（）：将其他数据类型分解添加到列表内(扩展多个)

#一、将其他列表元素添加至列表内
	name =["xiaowu","little-five","James"]
	name.extend(["alex","green"])
	print(name)
	# 输出：['xiaowu', 'little-five', 'James', 'alex', 'green']

#二、将字符串元素添加到列表内
	name =["xiaowu","little-five","James"]
	name.extend("hello")
	print(name)
	# 输出：['xiaowu', 'little-five', 'James', 'h', 'e', 'l', 'l', 'o']

#三、将字典元素添加至列表内，注：字典的key。
	name =["xiaowu","little-five","James"]
	name.extend({
     "hello":"world"})
	print(name)
	# 输出：['xiaowu', 'little-five', 'James', 'hello']
# 四 append()与extend()的不同
	# append（）
		name =["xiaowu","little-five","James"]
		name.append(["hello","world"])
		print(name)
		# 输出：['xiaowu', 'little-five', 'James', ['hello', 'world']]     #不同
	
	# extend（）
		name =["xiaowu","little-five","James"]
		name.extend(["hello","world"])
		print(name)
		# 输出：['xiaowu', 'little-five', 'James', 'hello', 'world']      #不同  

4.6 insert（）插入

• 可以指定插入列表的某个位置，前面提到过列表是有序的

	name =["xiaowu","little-five","James"]
	name.insert(1,"alex") #索引从0开始，即第二个
	print(name)
	# 输出：['xiaowu', 'alex', 'little-five', 'James']

4.7 pop() 取出

• 可将取出的值作为字符串赋予另外一个变量

	name =["xiaowu","little-five","James"]
	special_name =name.pop(1)
	print(name)
	# 输出：['xiaowu', 'James']
	print(special_name,type(special_name))
	# 输出：little-five 

4.8 remove() 移除、del () 删除

#remove -->移除，其参数为列表的值的名称
	name =["xiaowu","little-five","James"]
	name.remove("xiaowu")
	print(name)
	# 输出：['little-five', 'James']

#del -->删除
	name =["xiaowu","little-five","James"]
	#name.remove("xiaowu")
	del name[1]
	print(name)
	# 输出：['xiaowu', 'James']

4.9 sorted()–>排序，

• 默认正序，加入reverse =True，则表示倒序

>>> #正序
		# 数字排序
			num =[11,55,88,66,35,42]
			print(sorted(num))
			# 输出：[11, 35, 42, 55, 66, 88]

		#字符串排序
			name =["xiaowu","little-five","James"]
			print(sorted(name))
			# 输出：['James', 'little-five', 'xiaowu']

#倒序
		# 数字排序
			num =[11,55,88,66,35,42]
			print(sorted(num,reverse=True))
			# 输出：[88, 66, 55, 42, 35, 11]

4.10 比较大小

• 字符串比较AXCii码
• list1[i]与list2[i]作比较

# ist1[0]与list2[0]作比较，(789 > 123 )后边的不做比较了
	list1 = [123,789]
	list2 = [789,123]
	list1 < list2
	# 输出：True

4.11 拼接

• +两边的数据类型必须是一致的

	list1 = [123,789]
	list2 = [789,123]
	list3 = list1 + list2
	list3
	# 输出：[123, 789, 789, 123]

4.12 列表复制

• 利用*

list1 = [123, 789]
list3 = list2*3
list2
# 输出：[789, 123]
list3
# 输出：[789, 123, 789, 123, 789, 123]

5.元组 tuple类

• 元组即为不可修改的列表。其于特性跟list相似。其使用圆括号（次）和逗号（主）来标识。

5.1 定义元组

# 定义一个空元组
	tuple1 = ()
	type(tuple1)
	# 输出：
# 为什么用逗号标识
	# 不加逗号，int类型
		tuple2 = (1)
		type(tuple2)
		# 输出：
	# 加逗号，元组类型
		tuple3 = (1,)
		type(tuple3)
		# 输出：
	# 只用逗号，不用小括号
		tuple5 = 2,
		type(tuple5)
		# 输出：
	
# 定义一个name元组
	name = ("little-five","xiaowu")
	print(name)
	# 输出：('little-five', 'xiaowu')
# 修改元组元素
	name[0] = 'update'
	# 输出：报错 ：Traceback (most recent call last):
	#  File "", line 1, in 
	#    name[0] = 'update'
	#TypeError: 'tuple' object does not support item assignment
		

5.2 元组元素的添加

• 把元组分成两部分，利用拼接赋值组合到一起

	# 注意：('弗兰奇',)的逗号
	name = ('蒙奇D·路飞', '索隆', '乔巴', '山治', '妮可罗宾', '娜美')
	name[:4] + ('弗兰奇',) + name[4:]
	# 输出：('蒙奇D·路飞', '索隆', '乔巴', '山治', '弗兰奇', '妮可罗宾', '娜美')

6 .字典-无序的 —>dict类

6.1 字典的定义

• 字典为一系列的键值对，每个键值对用,隔开，键与值之间用：隔开。
• 键的定义必须是不可变的，即可以是数字、字符串也可以是元组，还有布尔值等。
• 值的定义可以是任意数据类型

6.1 基本语法

#字典的定义
	info ={
     
		1:"hello world",  #键为数字
		("zhang"):"张",   #键为元组
		False:{
                #键为布尔
			"name":"James"
		       },
		"age":22          #键为字符串
		}
	print(info)
	# 输出：{False: {'name': 'James'}, 1: 'hello world', 'age': 22, 'zhang': '张'}

6.2 遍历 -->items、keys、values

# 定义字典info 
	info ={
     
	   "name":"little-five",
	   "age":22,
	   "email":"99426353*@qq,com"
	}
# 遍历字典info的键
	# 方式1-for循环遍历
		for key in info:
		print(key)	
		# 输出：
				email
				age
				name

	# 方式2 keys()函数遍历
		print(info.keys())
		# 输出：dict_keys(['email', 'age', 'name'])

#遍历字典info的值
	print(info.values())
	# 输出：dict_values(['99426353*@qq,com', 22, 'little-five'])

#遍历字典info的键值对
	print(info.items())
	# 输出：dict_items([('email', '99426353*@qq,com'), ('age', 22), ('name', 'little-five')])

7.集合

7.1 关于集合set的定义：

1. 相当于一个容器， 可存可取
2. 数据是无序的，很难指定单独去取某一个元素
3. 但可以通过一定的方法筛选去获得你需要的那部分元素。
4. 故集合可以创建、增、删、关系运算。
5. 用{}存储，标识，中间用,隔开

7.2 集合的特性：

• 去重
• 无序
• 每个元素必须为不可变类型即（hashable类型，可作为字典的key）。

7.3 定义一个集合

• 创建，将会自动去重,
• 其元素为不可变数据类型，即数字、字符串、元组
• 不可变集合的创建 -->frozenset()

#方式1
	test01 ={
     "zhangsan","lisi","wangwu","lisi",666,("hello","world",),True}
#方式2 set()
	test02 =set({
     "zhangsan","lisi","wangwu","lisi",666,("hello","world",),True})
#方式3 不可变集合的创建 -->frozenset()
	test =frozenset({
     "zhangsan","lisi","wangwu","lisi",666,("hello","world",),True})

7.4 增：add、update

• 更新单个值 add()
• 更新多个值 update()

#更新单个值 add()
	names ={
     "zhangsan","lisi","wangwu"}
	names.add("james") #其参数必须为hashable类型
	print(names)
	# 输出：{'james', 'wangwu', 'zhangsan', 'lisi'}

#更新多个值 update()
	names ={
     "zhangsan","lisi","wangwu"}
	names.update({
     "alex","james"})#其参数必须为集合
	print(names)
	# 输出：{'james', 'alex', 'wangwu', 'zhangsan', 'lisi'}

7.5 删除：pop、remove、discard

• 随机删除 pop()
• 指定删除，若要删除的元素不存在，则报错 remove()
• 指定删除，若要删除的元素不存在，无视该方法discard()

# pop()随机删除
	names ={
     "zhangsan","lisi","wangwu","alex","james"}
	names.pop()
	# 输出：'alex'
	print(names)
	# 输出：{'lisi', 'james', 'zhangsan', 'wangwu'}
# remove()指定删除，若要删除的元素不存在，则报错 
	names ={
     "zhangsan","lisi","wangwu","alex","james"}
	names.remove("lisi")
	print(names)
	# 输出：{'alex', 'james', 'zhangsan', 'wangwu'}
# discard() 指定删除，若要删除的元素不存在，无视该方法 
	names ={
     "zhangsan","lisi","wangwu","alex","james"}
	names.discard("hello")
	print(names)
	# 输出：{'alex', 'lisi', 'james', 'zhangsan', 'wangwu'}

7.6 关系运算：交集 & 、并集 | 、差集 - 、交差补集 ^ 、 issubset 、isupperset

# 定义两个集合 
	english_c ={
     "ZhangSan","LiSi","James","Alex"}
	math_c ={
     "WangWu","LiuDeHua","James","Alex"}

# 交集  in a and in b
		# 方式1 
			print(english_c & math_c)
			# 输出：{'Alex', 'James'}
		# 方式2
			print(english_c.intersection(math_c))
			# 输出：{'Alex', 'James'}
# 并集 in a or in b
	# 方式1
		print(english_c | math_c)
		# 输出：{'James', 'LiSi', 'ZhangSan', 'LiuDeHua', 'Alex', 'WangWu'}
	# 方式2
		print(english_c.union(math_c))
		# 输出：{'James', 'LiSi', 'ZhangSan', 'LiuDeHua', 'Alex', 'WangWu'}
# 差集 in a not in b
	# 方式1
		print(english_c - math_c)
		# 输出：{'ZhangSan', 'LiSi'}
	# 方式2
		print(english_c.difference(math_c))
		# 输出：{'ZhangSan', 'LiSi'}
# 交差补集 （A∪B - A∩B）
	print(english_c ^ math_c)
	# 输出：{'LiSi', 'ZhangSan', 'LiuDeHua', 'WangWu'}

7.7 判断两个集合的关系是否为子集、父集 --> issubset 、isupperset

• issubset():判断n 是否为 m 的子集
• issuperset ():判断 n 是否为 m 的父集

# 定义 n,m,l三个集合
	n ={
     1,2,4,6,8,10}
	m ={
     2,4,6}
	l ={
     1,2,11}
# 判断n 是否为 m的父集
	# 方式1
		print(n >= m)
		# 输出：True
	# 方式2
		print(n.issuperset(m)) 
		# 输出：True
# 判断n 是否为l的父集
	print(n.issuperset(l)) 
	# 输出：False
# 判断 m 是否为 n的子集
	# 方式1
		print(m <=n)
		# 输出：True
	# 方式2
		print(m.issubset(n))    
		# 输出：True

8.科学计数法（e计数发）默认浮点型

	a = 0.000000000025
	a
	# 输出：2.5e-11

	a = 1.5e10
	a
	# 输出：15000000000.0

解释：$$2.5\times 10^{-11}$$ $$1.5\times 10^{10}$$