【Python全栈系列课程（一）】Python基础入门

老夏

第六章 变量转换
    6.8 set()函数

        通过使用set()函数可以将字符串、列表和元组转划为集合。
（1）字符串转集合

1. val='linux'
   
2. print(set(val))

复制代码

（2）列表转集合

1. val=[7,1,3,3,5]
   
2. print(set(val))        

复制代码

（3）元组转集合

1. val=(7,1,3,3,5)
   
2. print(set(val))

复制代码

老夏

第六章 变量转换
    6.9 dict()函数

        通过使用dict()函数可以将列表和元组转划为字典。
（1）列表转字典
        列表内的值必须是键值对形式的列表才可以转划为字典。

1. # 由于字典需要key和value，所以此时报错
   
2. val=[5,2,3,5]
   
3. print(dict(val))
   
4. # 此时可以正常转换
   
5. val=[[1,'php'],[2,'linux']]
   
6. print(dict(val))
   
7. # 列表内的值为键值对形式的元组也可以转划为字典。
   
8. val=[(1,'php'),(2,'linux')]
   
9. print(dict(val))
   
10. # 通过使用zip()函数将两个列表转划为字典
    
11. x=[1,3,5]
    
12. y=['python','linux','php']
    
13. dc=dict(zip(x,y))
    
14. print(dc)

复制代码

（2）元组转字典
        元组内的值必须是键值对形式的元组才可以转划为字典。

1. # 由于字典需要key和value，所以此时报错
   
2. val=(7,2,3,4,5)
   
3. print(dict(val))
   
4. # 此时可以正常转换
   
5. val=(('7','linux'),('2','php'))
   
6. print(dict(val))
   
7. # 元组内的值为键值对形式的列表也可以转划为字典。
   
8. val=([1,'php'],[2,'linux'])
   
9. print(dict(val))
   
10. # 通过使用zip()函数将两个元组转划为字典
    
11. x=(1,3,5)
    
12. y=('python','linux','php')
    
13. dc=dict(zip(x,y))
    
14. print(dc)

复制代码

老夏

第七章 运算符
    7.1 数学运算符

运算符	描述	实例
+	加	a=3 b=2 a+b=5
-	减	a=3 b=2 a-b=1
*	乘	a=3 b=2 a*b=6 c='hello' print(c*2)
/	除	a=4 b=2 a/b=2.0
//	整除	a=3 b=2 a//b=2
%	取余	a=3 b=2 a%b=1
**	次幂	a=3 b=2 a**b=9

老夏

第七章 运算符
    7.2 比较运算符

运算符	描述	实例
>	大于	a=3 b=2 a>b
<	小于	a=3 b=2 a<b
>=	大于等于	a=3 b=2 a>=b
<=	小于等于	a=3 b=2 a<=b
==	等于	a=3 b=2 a==b
!=	不等于	a=3 b=2 a!=b

老夏

第七章 运算符
    7.3 逻辑运算符

（1）and运算符  
        当x为假时，返回x的值，否则返回y的值。

1. x=0
   
2. y=2
   
3. print(x and y)

复制代码

（2）or运算符
        当x为真时，返回x的值，否则返回y的值。

1. x=0
   
2. y=2
   
3. print(x or y)

复制代码

（3）not运算符
        当x为真时，则返回假，当x为假时，则返回真。

1. x=10
   
2. print(not x)

复制代码

老夏

第七章 运算符
    7.4 赋值运算符

运算符	描述	实例
=	赋值运算符	c=a+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）

老夏

第七章 运算符
    7.5 位运算符

（1）&（位与）
        将参与运算的两数所对应的二进制位相与。

1. x=3
   
2. y=2
   
3. print(x & y)
   
4. '''
   
5. 011
   
6. 010
   
7. ------
   
8. 010=2
   
9. '''

复制代码

（2）|（位或）
        将参与运算的两数所对应的二进制位相或。

1. x=3
   
2. y=2
   
3. print(x | y)
   
4. '''
   
5. 011
   
6. 010
   
7. ------
   
8. 011=3
   
9. '''

复制代码

老夏

第七章 运算符
    7.6 成员运算符

        成员运算符主要应用于列表、元组、字典和集合。
（1）in运算符

1. lt=['user1','user2','user3']
   
2. # 返回值为布尔型值
   
3. print('user1' in lt)
   
4. dt={'name1':'user1','name2':'user2'}
   
5. # 注意，字典只能查找键值
   
6. print('name2' in dt)

复制代码

（2）not in运算符

1. lt=['user1','user2','user3']
   
2. print('user1' not in lt)

复制代码

老夏

第七章 运算符
    7.7 引用运算符

一、整型、浮点型、字符串、布尔型和None中的引用
（1）如果值相同，则使用相同的内存地址引用

1. x=10
   
2. y=10
   
3. z=y
   
4. # id()函数用于获取对象的内存地址
   
5. print(id(x))
   
6. print(id(y))
   
7. print(id(z))

复制代码

（2）如果值不同，则使用不相同的内存地址引用

1. x=10;
   
2. y=20
   
3. z=y
   
4. z=30
   
5. # id()函数用于获取对象的内存地址
   
6. print(id(x))
   
7. print(id(y))
   
8. print(id(z))

复制代码

二、列表、元组、集合、字典和对象中的引用
（1）针对大长度的变量类型，无论两个变量的值是否相同，都会使用不同的内存地址引用

1. ltx=[]
   
2. lty=[]
   
3. print(id(ltx))
   
4. print(id(lty))

复制代码

（2）如果使用赋值，则会使用相同的内存地址引用

1. ltx=[]
   
2. lty=ltx
   
3. print(id(ltx))
   
4. print(id(lty))

复制代码

        总结，如果整型、浮点型、字符串、布尔型和None类型变量的值相同，或者使用"赋值运算符"，则意味着使用同一个内存地址，一旦将其值重新调整，该变量的内存地址也会跟着发生改变；列表、元组、集合、字典和对象类型的变量无论值是否相同，都不使用同一个内存地址，但是通过使用"赋值运算符"，则会使其使用同一个内存地址，只有将其中的一个变量重新赋值才会更改其内存地址，注意，如果仅更改变量内部中的元素值，则无法更改其内存地址，即内存地址仍然相同，所以，两个变量的值会同时发生改变。

1. # 整型、浮点型、字符串、布尔型、None
   
2. x=1
   
3. y=x
   
4. x=100
   
5. print(id(x))
   
6. print(id(y))
   
7. print(x)
   
8. print(y)
   
9. # 列表、元组、集合、字典、对象
   
10. ltx=[1,3,5,7]
    
11. lty=ltx
    
12. ltx[0]=100
    
13. print(id(ltx))
    
14. print(id(lty))
    
15. print(ltx)
    
16. print(lty)

复制代码

三、is和is not运算符
        【is】和【is not】运算符比较的是变量的内存地址引用。

1. x=1
   
2. y=x
   
3. x=100
   
4. # 相当于使用print(id(x)==id(y))
   
5. print(x is y)

复制代码

老夏

第七章 运算符
    7.8 运算符优先级和结合性

一、运算符优先级
        所谓优先级，就是当多个运算符同时出现在一个表达式中时，先执行哪个运算符。

优先级	运算符	Python运算符	结合性
19	小括号	()	无
18	索引运算符	x 或 x[i1: i2 [:i3]]	左
17	属性访问	x.attribute	左
16	次幂	**	左
15	按位取反	~	右
14	符号运算符	+（正号）、-（负号）	右
13	乘除	*、/、//、%	左
12	加减	+、-	左
11	位移	>>、<<	左
10	按位与	&	右
9	按位异或	^	左
8	按位或	|	左
7	比较运算符	==、!=、>、>=、<、<=	左
6	is运算符	is、is not	左
5	in运算符	in、not in	左
4	逻辑非	not	右
3	逻辑与	and	左
2	逻辑或	or	左
1	逗号运算符	exp1, exp2	左

        虽然Python运算符存在优先级的关系，但仍不推荐过度依赖运算符的优先级，这会导致程序的可读性降低。因此建议大家：一，不要把一个表达式写得过于复杂，如果一个表达式过于复杂，可以尝试把它拆分来书写；二，不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用小括号来控制表达式的执行顺序。

二、运算符结合性
        所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。
        例如，对于表达式【100/25*16】，【/】和【*】的优先级相同，这时候就不能只依赖运算符优先级，还要参考运算符的结合性，【/】和【*】都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果为64。
        Python中大部分运算符都具有左结合性，也就是从左到右执行；只有单目运算符（例如逻辑非运算符等）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。
        综上所述，当一个表达式中出现多个运算符时，Python会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符。