一、基本数据类型

1.1、算数运算符

print(10 + 3.1)
print(10 + 3)
print(10 / 3) # 结果带小数
print(10 // 3) # 只保留整数部分
print(10 % 3) # 取模、取余数
print(10 ** 3) # 3次方

1.2、比较运算符

、>=、<、<=、==、!=
print(10 > 3)
print(10 == 10)

print(10 >= 10)
print(10 >= 3)

name=input(‘your name: ‘)
print(name == ‘egon’)

1.3、赋值运算符

1.3.1 =：变量的赋值

1.3.2 增量赋值：

age = 18
age += 1 age=age + 1
print(age)

age=3
age/=3
age%=3
age*=3 # age=age3

1.3.3 链式赋值

x=10
y=x
z=y
z = y = x = 10 # 链式赋值
print(x, y, z)
print(id(x), id(y), id(z))

1.3.4 交叉赋值

  1. m=10
  2. n=20
  3. print(m,n)
  4. 交换值
  5. temp=m
  6. m=n
  7. n=temp
  8. print(m,n)
  10. m,n=n,m # 交叉赋值
  11. print(m,n)

1.3.5 解压赋值

  2. salaries=[111,222,333,444,555]
  3. 把五个月的工资取出来分别赋值给不同的变量名
  4. mon0=salaries[0]
  5. mon1=salaries[1]
  6. mon2=salaries[2]
  7. mon3=salaries[3]
  8. mon4=salaries[4]

解压赋值
mon0,mon1,mon2,mon3=salaries # 对应的变量名少一个不行
mon0,mon1,mon2,mon3,mon4,mon5=salaries # 对应的变量名多一个也不行

引入，可以帮助我们取两头的值，无法取中间的值
取前三个值
x,y,z,=salaries=[111,222,333,444,555] # *会将没有对应关系的值存成列表然后赋值给紧跟其后的那个变量名，此处为
print(x,y,z)
print(_)

取后三个值
*_,x,y,z=salaries=[111,222,333,444,555]
print(x,y,z)

取第一个和后两个
x,*_,y,z=salaries=[111,222,333,444,555]
print(x,y,z)

salaries=[111,222,333,444,555]
,*middle,=salaries
print(middle)

解压字典默认解压出来的是字典的key
x,y,z=dic={‘a’:1,’b’:2,’c’:3}
print(x,y,z)

1.4、可变不可变类型

可变类型：值改变，id不变，证明改的是原值，证明原值是可以被改变的
不可变类型：值改变，id也变了，证明是产生新的值，压根没有改变原值，证明原值是不可以被修改的

2、验证
2.1 int是不可变类型
x=10
print(id(x))
x=11 # 产生新值
print(id(x))

2.2 float是不可变类型

2.3 str是不可变类型

小结：int、float、str都被设计成了不可分割的整体，不能够被改变

2.4 list是可变类型

l=[‘aaa’,’bbb’,’ccc’]
print(id(l))
l[0]=’AAA’
print(l)
print(id(l))

2.5 dict 是可变类型
dic={‘k1’:111,’k2’:222}
print(id(dic))
dic[‘k1’]=3333333333
print(dic)
print(id(dic))

2.6 bool不可变

关于字典补充：
定义：{}内用逗号分隔开多key:value,
其中value可以是任意类型
但是key必须是不可变类型

  1. dic={
  2.     'k1':111,
  3.     'k2':3.1,
  4.     'k3':[333,],
  5.     'k4':{'name':'egon'}
  6. }
  8. dic={
  9.     2222:111,
  10.     3.3:3.1,
  11.     'k3':[333,],
  12.     'k4':{'name':'egon'}
  13. }
  14. print(dic[3.3])
  16. dic={[1,2,3]:33333333}
  17. dic={{'a':1}:33333333}

2、什么是条件？什么可以当做条件？为何要要用条件？

第一大类：显式布尔值
2.1 条件可以是：比较运算符
age = 18
print(age > 16) # 条件判断之后会得到一个布尔值

2.1 条件可以是：True、False
is_beautiful=True
print(is_beautiful)

第二大类：隐式布尔值，所有的值都可以当成条件去用
其中0、None、空(空字符串、空列表、空字典)=》代表的布尔值为False，其余都为真

二、逻辑运算符

2.1：not、and、or的基本使用

not：就是把紧跟其后的那个条件结果取反
ps：not与紧跟其后的那个条件是一个不可分割的整体
print(not 16 > 13)
print(not True)
print(not False)
print(not 10)
print(not 0)
print(not None)
print(not ‘’)

and：逻辑与，and用来链接左右两个条件，两个条件同时为True，最终结果才为真
print(True and 10 > 3)

print(True and 10 > 3 and 10 and 0) #条件全为真，最终结果才为True
print( 10 > 3 and 10 and 0 and 1 > 3 and 4 == 4 and 3 != 3) #偷懒原则

or：逻辑或，or用来链接左右两个条件，两个条件但凡有一个为True，最终结果就为True，
两个条件都为False的情况下，最终结果才为False
print(3 > 2 or 0)
print(3 > 4 or False or 3 != 2 or 3 > 2 or True) # 偷懒原则

2.2：优先级not>and>or

ps：
如果单独就只是一串and链接，或者说单独就只是一串or链接，按照从左到右的顺讯依次运算即可（偷懒原则）
如果是混用，则需要考虑优先级了

res=3>4 and not 4>3 or 1==3 and ‘x’ == ‘x’ or 3 >3
print(res)

  1.   False                 False              False<br />res=(3>4 and (not 4>3)) or (1==3 and 'x' == 'x') or 3 >3<br />print(res)

res=3>4 and ((not 4>3) or 1==3) and (‘x’ == ‘x’ or 3 >3)
print(res)

三、成员运算符

print(“egon” in “hello egon”) # 判断一个字符串是否存在于一个大字符串中
print(“e” in “hello egon”) # 判断一个字符串是否存在于一个大字符串中

print(111 in [111,222,33]) # 判断元素是否存在于列表

判断key是否存在于字典
print(111 in {“k1”:111,’k2’:222})
print(“k1” in {“k1”:111,’k2’:222})

not in
print(“egon” not in “hello egon”) # 推荐使用
print(not “egon” in “hello egon”) # 逻辑同上，但语义不明确，不推荐

2、身份运算符
is # 判断的是id是否相等

四、if判断语句

4.1 语法1:

if 条件:
代码1
代码2
代码3
‘’’

4.2 语法2:

if 条件:
代码1
代码2
代码3
else:
代码1
代码2
代码3
‘’’

age = 60
is_beautiful = True
star = ‘水平座’

if age > 16 and age < 20 and is_beautiful and star == ‘水平座’:
print(‘我喜欢，我们在一起吧。。。’)
else:
print(‘阿姨好，我逗你玩呢，深藏功与名’)

print(‘其他代码………….’)

‘’’

4.3 语法3:

if 条件1:
代码1
代码2
代码3
elif 条件2:
代码1
代码2
代码3
elif 条件2:
代码1
代码2
代码3

score=73
if score >= 90:
print(‘优秀’)
elif score >= 80 and score < 90:
print(‘良好’)
elif score >= 70 and score < 80:
print(‘普通’)

改进

  1. score = input('请输入您的成绩：') score="18"
  2. score=int(score)
  3. if score >= 90:
  4.     print('优秀')
  5. elif score >= 80:
  6.     print('良好')
  7. elif score >= 70:
  8.     print('普通')

语法3:
if 条件1:
代码1
代码2
代码3
elif 条件2:
代码1
代码2
代码3
elif 条件2:
代码1
代码2
代码3
…
else:
代码1
代码2
代码3
‘’’

  1. score = input('请输入您的成绩：') # score="18"
  2. score=int(score)
  3. if score >= 90:
  4.     print('优秀')
  5. elif score >= 80:
  6.     print('良好')
  7. elif score >= 70:
  8.     print('普通')
  9. else:
  10.     print('很差，小垃圾')
  11. print('=====>')

‘’’
if嵌套if
‘’’

  1. age = 17
  2. is_beautiful = True
  3. star = '水平座'
  4. if 16 < age < 20 and is_beautiful and star == '水平座':
  5.     print('开始表白。。。。。')
  6.     is_successful = True
  7.     if is_successful:
  8.         print('两个从此过上没羞没臊的生活。。。')
  9. else:
  10.     print('阿姨好，我逗你玩呢，深藏功与名')
  12. print('其他代码.............')

五、浅copy

list1=[
‘egon’,
‘lxx’,
[1,2]
]
image.png
5.1、二者分隔不开，list改list2也跟着该，因为指向的就是同一个地址
list2=list1 # 这不叫copy
list1[0]=’EGON’
print(list2)

5.2、需求：
1、拷贝一下原列表产生一个新的列表
2、想让两个列表完全独立开，并且针对的是改操作的独立而不是读操作

5.3、如何copy列表
3.1 浅copy:是把原列表第一层的内存地址不加区分完全copy一份给新列表
list1=[
‘egon’,
‘lxx’,
[1,2]
]

list3=list1.copy()
print(list3)
print(id(list1))
print(id(list3))

print(id(list1[0]),id(list1[1]),id(list1[2]))
print(id(list3[0]),id(list3[1]),id(list3[2]))

实验1：对于不可变类型的赋值，都是产生了新值，让原列表的索引指向新的
内存地址，并不会影响新列表
list1[0]=’EGON’
list1[1]=’LXX’
list1[2]=123

实验2：但对于可变类型，我们可以改变可变类型中包含的值，但内存地址不变
即原列表的索引指向仍然指向原来的内存地址，于是新列表也跟着一起受
影响，如下
list1[2][0]=111
list1[2][1]=222
print(list1)
print(list3)

综合实验1和实验2可以得出，要想copy得到的新列表与原列表的改操作完全独立开
必须有一种可以区分开可变类型与不可变类型的copy机制，这就是深copy

3.2 深copy

  1. import copy
  2. list1=[
  3.     'egon',
  4.     'lxx',
  5.     [1,2]
  6. ]
  8. list3=copy.deepcopy(list1)
  9. print(id(list1))
  10. print(id(list3))
  11. print(list3)
  12. #          不可变        不可变        可变
  13. print(id(list1[0]),id(list1[1]),id(list1[2]))
  14. print(id(list3[0]),id(list3[1]),id(list3[2]))
  15. '''
  16. 4497919088 4498367856 4498449216
  17. 4497919088 4498367856 4498595328
  18. '''
  19. print(list3)
  20. print(id(list1[2][0]),id(list1[2][1]))
  21. print(id(list3[2][0]),id(list3[2][1]))
  23. list1[0]='EGON'
  24. list1[1]='LXX'
  26. list1[2][0]=111
  27. list1[2][1]=222
  28. print(list1)
  30. print(list3)