1 用户交互

1.1 input()接收用户的输入

计算机接收用户的输入

在Python2中：
raw_input():用法与Python3的input一模一样
input(): 要求用户必须输入一个明确的数据类型，输入的是什么类型，就存成什么类型, 方便了程序开发者, 无需考虑用户输入, 用户需要按照Python的要求去输入数据类型

在Python3中：
input会将用户输入的所有内容都存成字符串类型,方便用户, 由程序员去开发程序识别解释用户输入

username = input("请输入用户名: ")
print(username)
>> 
请输入用户名: admin
admin

age = int(input("请输入年龄: "))   # int只能将纯整型的字符串转成整型, '1.1'是无法转换的, 也无法转换字符➕整型混合
print(age,type(age))
>>
请输入年龄: 18
18 <class 'int'>

1.2 字符串格式化输出

1.2.1 "字符串"%() + %s

Python各版本都适用

值或者变量在()中按照位置与%s一一对应，少一个不行，多一个也不行

# 单纯的传值
info = '''
用户名是%s, 密码是%s
''' %('david',20)
print(info)

>> 用户名是david, 密码是20

# 可以传变量
username = input("请输入用户名: ")
password = input("请输入密码: ")

info = '''
==============
用户名是%s,密码是%s
==============

''' % (username,password)
print(info)

>>
==============
用户名是admin,密码是admin
==============

# 前两种方式是按照%()中的值的顺序, 给%s一一传值, 需要记住顺序才行, 不方便, 可以利用字典传值, 但是用字典传值也是显得很臃肿

username = input("请输入用户名: ")
password = input("请输入密码: ")

info = '''
==============
用户名是%(name)s,密码是%(password)s # %s改用%()s占位, 括号里写后面字典的key
==============

''' % ({'name':username,'password':password}) # %()中存字典, 字典的key和%()s的key要对应, 也就是%()s中定义的key, 在%()的字典中必须存在, 但是没有顺序关系, 而value的值可以通过变量取

print(info)
>>
请输入用户名: admin
请输入密码: admin

==============
用户名是admin,密码是admin
==============

# %s可以接收任意类型的值

print('my name is %s'%('haha'))
print('my name is %s'%(18))
print('my name is %s'%([11,22,33]))
print('my name is %s'%({'name','admin'}))
>>
my name is haha
my name is 18
my name is [11, 22, 33]
my name is {'name', 'admin'}

# 如果规定必须是数字, 那么可以用%d
print('my name is %d'%('18'))
>> 
print('my name is %d'%('18'))
TypeError: %d format: a number is required, not str

print('my name is %d'%(18))
>> my name is 18

如果需要输出%, 那么要写两个%
>>> print("百分比: %d%%"%(97))
百分比: 97%

1.2.2 "string".format()

Python2.6以后引用, 兼容性好

# 按位置传值
print("my name is {} and my age is {}".format('admin',19))
>> print("my name is {} and my age is {}".format('admin',19))

# 按索引编号传值
print("my name is {0} and my age is {1}".format('admin',20))
>> my name is admin and my age is 20

# 按字典传值
print("my name is {name} and my age is {age}".format(name="admin",age=20))
>> my name is admin and my age is 20

1.2.3 f"字符串"

Python3.5以后才推出, 以变量的形式接收用户的输入

username = 'admin'
password = 'password'

print(f'用户名是{username},密码是{password}')
>> 用户名是admin,密码是password

1.2.4 f 补充功能

f 运行字符串里的功能

f'{print("aaaa")}'
>> aaaa

res = f'{10 + 3}'
print(res)
>> 13

总结:

三种字符串格式化输出的效率

f > str.format > %

1.2.4 填充与格式化

# 先取到值,然后在冒号后设定填充格式：[填充字符][对齐方式][宽度]
*<10：左对齐，总共10个字符，不够的用*号填充

print('{0:*<10}'.format('开始执行')) # 开始执行******

*>10：右对齐，总共10个字符，不够的用*号填充
 print('{0:*>10}'.format('开始执行')) # ******开始执行

*^10：居中显示，总共10个字符，不够的用*号填充
print('{0:*^10}'.format('开始执行')) # ***开始执行***

print('{x}=============='.format(x='开始执行')) # 开始执行******
print('{x}==========='.format(x='开始执行')) # 开始执行===========
print('{x:=<10}'.format(x='开始执行')) # 开始执行======, x取到的值居左显示, :=<10表示x取到的值占的字符位置如果不足10, 则用=填充
print('{x:=>10}'.format(x='开始执行')) # ======开始执行, x取到的值居右对齐
print('{x:=^13}'.format(x='开始执行')) # ===开始执行===, x取到的值居中, 左右补等号, 如果剩余位数奇数位, 则右边多补

1.2.5 精度与进制

print('{salary:.3f}'.format(salary=1232132.12351))  #精确到小数点后3位，四舍五入，结果为：1232132.124
print('{0:b}'.format(123))  # 转成二进制，结果为：1111011
print('{0:o}'.format(9))  # 转成八进制，结果为：11
print('{0:x}'.format(15))  # 转成十六进制，结果为：f
print('{0:,}'.format(99812939393931))  # 千分位格式化，结果为：99,812,939,393,931

2 基本运算符

2.1 算术运算符

解释器中单纯的输入1+1是不会报错的, 因为1和+都是解释器能解释的数据, 并且解释器会做计算
只是因为没有print, 所以运行后是没有结果的

print(10 + 3.1)
print(10 + 3)
print(10 / 3)  # 结果带小数
print(10 // 3)  # 只保留整数部分, 不是四舍五入
print(10 % 3) # 取模、取余数
print(10 ** 3) # 次方, 10的3次方
+ 号一般用于数字计算, 不要用来做字符串拼接, 效率很低

2.2 比较运算符

>、>=、<、<=、==、!=不等于

print(10 > 3) # True
print(10 == 10) # True
print(10 >= 10) # True
print(10 >= 3) # True

age = input("age: ")
print(age == 20)
>>
age: 20
False

# Python3中, 用户的输入都被认为是字符串, 因此, 与数字做比较时, 要先把用户输入转成整型或float
age = int(input("age: "))
print(age == 20)

2.3 赋值运算符

2.3.1 变量赋值

=：变量的赋值

x = 10
print(x)
>> 10

2.3.2 增量赋值

增量赋值, 会在单独的内存空间存放新的值, 然后把新的值再绑定给变量, 原值的内存空间会被回收, 因为已经没有变量名和它绑定

age = 18
age += 1  # age=age + 1
print(age)
>> 19

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

2.3.3 链式赋值

把一个值赋值给多个变量名

x=10
y=x
z=y
z = y = x = 10 # 链式赋值
print(x, y, z)
>> 10 10 10
print(id(x), id(y), id(z))  # 链式赋值, 变量都指向相同的内存地址
>> 140731791185856 140731791185856 140731791185856

2.3.4 交叉赋值

m = 10
n = 20
print(m,n)
>> 10 20
m,n = n,m
print(m,n)
>> 20 10


# 第二种方式
m = 10
n = 20
print(m,n)
>> 10 20
Temp = m
m = n
n = Temp
print(m,n)
>> 20 10

2.3.5 解压赋值

2.3.5.1 列表解压

举例:

把五个月的工资取出来分别赋值给不同的变量名
salaries = [111, 222, 333, 444, 555]

mon0=salaries[0]
mon1=salaries[1]
mon2=salaries[2]
mon3=salaries[3]
mon4=salaries[4]

salaries = [111,222,333,444,555]
mon0,mon1,mon2,mon3,mon4=salaries
print(mon0,mon1,mon2,mon3,mon4)

引入*，可以帮助我们取两头的值，也可以取除了第一个和最后一个之间的值, 但是一般不用

name = ['name1','name2','name3','name4']
x,y,z,*_=name
print(x,y,z)
>> name1 name2 name3
*_,z=name
print(z)
>> name4
print(_)
>> ['name1', 'name2', 'name3'] 
# 所有没有被对应到的列表中的值, 都会被*接受, 复制给变量名'_', 所以print(_)的结果就是没有被解压的列表 
# '_'就是一个占位符, 用来接收没有对应关系的值, 存成列表
# *_只能使用一次, 其余用_
salaries=[111,222,333,444,555]
_,*middle,_=salaries
print(middle)
>> [222, 333, 444]

2.3.5.2 字典解压

解压字典默认解压出来的是字典的key

举例:

dic = {'a': 1, 'b': 2, 'c': 3}

dic = {'a': 1, 'b': 2, 'c': 3}
*_,x = dic
print(x)
>> c # 字典解压, 解出来的是key

3. 可变与不可变类型

可不可变看的是修改了变量值后, 变量名的id号码是否发生改变, 如果没有发生改变, 说明变量名所捆绑的内存地址是不变的, 变得只是该内存空间里的内容; 而如果id发生了变化, 说明变量名所捆绑的内存地址发生了变化, 因此改变变量值产生了新值, 变量名被捆绑到了新的内存空间, 那么id也就变了

3.1 可变类型

可变类型: 变量值改变, 但是id不变, 证明改的是原值, 原值是可以改变的
简单理解就是, 在变量值所在的内存空间中, 把原值修改, 但是内存地址还是原来的地址, 瓶子没变, 水换了

验证列表类型:

>>> list1 = [111,222,333]
>>> print(id(list1))
1364070899968
>>> list1[0] = 444
>>> print(list1)
[444, 222, 333]
>>> print(id(list1))
1364070899968

修改了列表中的值, 但是id没变,因此列表是可变类型

验证字典类型:

>>> dict = {'name':'admin','age':20}
>>> print(id(dict))
1364070846592
>>> dict['name'] = 'manager'
>>> print(dict)
{'name': 'manager', 'age': 20}
>>> print(id(dict))
1364070846592

字典的堆区存的是key：value的内存地址
修改了字典中的值, 但是id没变, 因此字典是可变类型

原理解析:

图片.png

3.2 不可变类型

不可变类型: 变量值改变了, id也发生改变, 证明原值是没有改的, 而是产生了新的值, 放在了新的内存空间地址. 因此, 原值不可被修改

验证整型:

>>> x = 10
>>> print(id(x))
140731787057088
>>> x = 11
>>> print(id(x))
140731787057120

修改了整型值, id发生了变化, 说明修改了x的值是产生了新的值, 开辟了新的内存空间, 把11放进去, 然后和x进行捆绑, x指向了新的内存地址, 因此id号也就发生了改变
因此, 整型是不可变类型, 所有的赋值都是产生新值, 需要开辟新的内存空间

验证浮点型:

>>> x = 1.1
>>> print(id(x))
1364070527376
>>> x = 2.2
>>> print(id(x))
1364070528080

浮点型也是不可变类型

验证字符串类型:

>>> x = 'aaa'
>>> print(id(x))
1364071217840
>>> x = 'bbb'
>>> print(id(x))
1364071217968

字符串也是不可变类型

原理解析:

图片.png

总结:

整型, 浮点和字符串都是一个整体, 其在内部是不可被分隔的, 无法只修改一个数字或者一个字符, 因此, 修改整型, 浮点, 字符串都是修改了一个整体. 同理, 布尔也是不可变的
列表, 字典, 都是容器类数据类型, 其内部的值是可以更改的, 但是容器本身是不变的