python初探--风变
1 注释符号#
2 变量声明：不带任何标记符号
3 print()
- 无引号-print() 、打印变量，数字常量，表达式等
- 单引号-print('') 、
- 双引号-print("")、和单引号效果无区别
- 三引号-print('''''')（三个单引号）、实现换行打印
4 转义字符：同其他语言
5 常用数据类型：整数，浮点数，字符串
6 运算
7 字符串的拼接
字符串只能与字符串拼接，拼接用+号。如果字符串和整数/浮点数拼接报错
8 type()函数
查看变量数据类型
9 数据转换
str()
转换成字符串类型。int类型和float类型都可以转换为str类型
int()
转换成整数类型
非整数形式的字符串不能用int转换
小数形式的字符串也不能用int()转换
float类型可以int转换，取整方式
float()--转换成浮点数类型
只要是数字形式的字符串都可以转换浮点数类型
整数都可以转换为浮点类型
10 严格的缩进形式：
四个空格或一个tab
在if条件语言中，缩进不需要我们手动按空格键。当你用英文输入法打:后按回车，自动缩进
11 分支结构：
if
if-else
if-elif-else
12 input()输入函数
可以带文字提示，例如input('请输入您的姓名：')
name = input('请输入您的姓名：')
input()返回值类型默认为str类型，可以用类型转换函数进行转换
13 列表LIST
list1=['小明',18,1.70]- 一个列表可以包括各种类型的数据（整数/浮点数/字符串/列表）
- 列表可以用print打印，print(list1),打印出的内容是：['小明',18,1.70]
- 偏移量:可以理解为一维数组的下标
- 从列表提取单个元素：print(list1[0])
- 从列表提取多个元素（切片操作）（提取的还是列表，而不是元素）(：号左边的包括，右边的不包括)
list2 = [5,6,7,8,9]
print(list2[:]) #输出 [5,6,7,8,9]
print(list2[2:]) #输出 [7,8,9]
print(list2[:2]) #输出 [5,6]
print(list2[1:3]) #输出 [6,7]
print(list2[2:4]) #输出 [7,8]6.给列表增加元素append()（只能增加一个元素）
list2 = [5,6,7,8,9]
list2.append(10) #为列表增加一个元素。只能一个，多个报错。结果为 [5,6,7,8,9,10]
list2.append([1,2]) #为列表增加一个列表类型的元素。结果为 [5,6,7,8,9,10,[1,2]]7.从列表中删除元素
del list2[0] #删除一个列表元素：
del list2[1:2] #删除列表片段（切片删除）
del list2[:] #删除列表片段（切片删除）
del list2 #删除整个列表 删完得到[]
14 字典：相当于php的关联数组
scores = {'小明':95,'小红':90,'小刚':90}- 大括号，键值对，键不能重复，值可重复。若键重复，取末尾的值
- len()函数来得出一个列表或者字典的长度（元素个数）
scores = {'小明':95,'小红':90,'小刚':90}
print(scores ['小明']) #提取字典元素
del scores ['小明'] #删除字典元素
scores['小明']=92 #增加字典元素
15 列表和字典的区别
- 列表中的元素是有序排列的。
- 两个元素相同，元素顺序不同的列表是两个不同的列表
- 字典中的元素是无序的，调动顺序也不影响。
- 列表可嵌套列表，字典
列表嵌套列表，相当于php的索引二维数组或索引多维数组
列表嵌套字典，相当于php的索引、关联混合二维数组，或多维
5.字典可嵌套字典，列表
字典嵌套字典，相当于php的关联二维数组，或关联多维数组。
字典嵌套列表，相当于php的关联、索引混合二维数组，或多维
16 for循环
- 语法for...in...
- 字符串，列表，字典都能循环
for i in [1,2,3,4,5]:
print(i)d = {'小明':'醋','小红':'油','小白':'盐','小张':'米'}
for i in d:
print(i) #打印键名
print(d[i]) #打印值
17 range()函数
常和for循环一起使用。当要固定循环n次时，可用此函数
range(x)生成一个从0到x-1的整数序列。
range(a,b) 函数，生成了一个【取头不取尾】的整数序列。
range(x,y,z)的意思是：从x数到y（+取头不取尾），步长为z。
18 while循环
a = 0
while a < 5:
a = a + 1
print(a)
19 布尔运算
- bool()函数可查看数据的真假
- 布尔值之间的运算：and、or、not、in、not in。in的意思是判断一个元素是否在一堆数据之中
- 如果涉及到的数据集合是字典的话，【in】和【not in】就可以用来判断字典中是否存在某个【键】
20 break语句
# break语句搭配for循环
for...in...:
...
if ...:
break
# break语句搭配while循环
while...(条件):
...
if ...:
break
21 continue语句
# continue语句搭配for循环
for...in...:
...
if ...:
continue
...
# continue语句搭配while循环
while...(条件):
...
if ...:
continue
...
22 pass语句
a = int(input('请输入一个整数:'))
if a >= 100:
pass #什么都不做，跳过
else:
print('你输入了一个小于100的数字')
23 else语句
没有碰到break的情况，会执行else
for i in range(5):
a = int(input('请输入0来结束循环，你有5次机会:'))
if a == 0:
print('你触发了break语句，循环结束，导致else语句不会生效。')
break
else:
print('5次循环你都错过了，else语句生效了。')
while...(条件):
...
break
else:
...
24 计时器
import time #调用time模块
time.sleep(5)
25 生成随机整数
import random
a = random.randint(1,100)
print(a)
#1<=a<=100
26 格式化字符串
print('血量：'+str(player_life)+' 攻击：'+str(player_attack))
#格式化字符串后
print('血量：%s 攻击：%s' % (player_life,player_attack))
#格式化字符串后
print('血量：{} 攻击：{}'.format(player_life,player_attack))
27 print不换行/换行/连接符
print('hello',end='')
print('world')
#输出 helloworld
print('hello',end='!')
print('world')
#输出hello!world
print('')
#换行
#正常情况下无end参数时，print()都是默认换行
print('hello','world',sep='-')
#输出hello-world
print('hello','world',sep='-',end='#')
#输出hello-world#
28 定义和调用函数
#语法-------------------------
def 函数名(参数):
函数体
return 语句 #return可省略，不返回;当return省略时，Python会在末尾隐性地加上return None
#定义和调用--------------------
def math(x):
y = x ** 2 + x
return y
a = math(10)
print(a)
#多参数，参数顺序-------------------
def menu(appetizer, course):
print('一份开胃菜：' + appetizer)
print('一份主食：' + course + '\n')
#参数需要按位置一一对应
menu('话梅花生','牛肉拉面')
#如果采用下面这种形式传递，就不需要理会参数位置
menu(course = '牛肉拉面', appetizer = '话梅花生')
#默认参数，默认参数必须放在位置参数之后-----------------------------------------------------
def menu(appetizer, course, dessert = '绿豆沙'):
print('一份开胃菜：' + appetizer)
print('一份主食：' + course)
print('一份甜品：' + dessert)
menu('话梅花生','牛肉拉面')
#默认参数也可改变，赋值即可
menu('话梅花生','牛肉拉面','银耳羹')
#不定长参数用*表示-----------------------------------------------------
def menu(*barbeque):
return barbeque
order = menu('烤鸡翅','烤茄子','烤玉米')
print(order) #输出('烤鸡翅', '烤茄子', '烤玉米')
print(type(order)) #类型为元组
#列表中的元素可以随时修改，但元组中的元素不可更改
#return多个值-----------------------------------------------------
import random
#引入random模块
appetizer = ['话梅花生','拍黄瓜','凉拌三丝']
def coupon(money):
if money < 5:
a = random.choice(appetizer)
return a
elif 5 <= money < 10:
b = random.choice (appetizer)
return b, '溏心蛋'
print(coupon(3))
print(coupon(6)) #返回元组类型
print(coupon[0])
print(coupon[1])
另外一种方式：我们也可以同时定义多个变量，来接收元组中的多个元素
dish, egg = coupon(6)
print(dish)
print(egg)
29 元组
元组的写法是将数据放在小括号()中，它的用法和列表用法类似，主要区别在于列表中的元素可以随时修改，但元组中的元素不可更改。
30 random.choice()
import random
random.choice( seq )
#seq -- 可以是一个列表，元组或字符串。
#返回随机项
31 print()详解
#print函数默认参数
print(*objects, sep = ' ', end = '\n', file = sys.stdout, flush = False)
#第一个参数objects带了*号，为不定长参数——这也是为什么print()函数可以传递任意数量的参数。
#sep控制多个值之间的分隔符，默认是空格
#end控制打印结果的结尾，默认是换行)
print('金枪鱼', '三文鱼', '鲷鱼') #输出 金枪鱼 三文鱼 鲷鱼
print('金枪鱼', '三文鱼', '鲷鱼', sep = '+') #输出 金枪鱼+三文鱼+鲷鱼
print('金枪鱼', '三文鱼', '鲷鱼', sep = '+', end = '=?') #输出 金枪鱼+三文鱼+鲷鱼=?
32 变量作用域
- 一个在函数内部赋值的变量仅能在该函数内部使用（局部作用域），它们被称作【局部变量】
- 在所有函数之外赋值的变量，可以在程序的任何位置使用（全局作用域），它们被称作【全局变量】
- global关键字，它可以将局部变量声明为全局变量
33 向上取整/向下取整
向上取整
import math
math.ceil(1.5)
向下取整int()
34 异常处理/多个异常处理可合并/常规错误的基类
try:
#尝试执行下列代码
......
except xxxx:
#try里报错就执行下列代码
......
num = [1,2,0,3]
for x in num:
try:
print(6 / x)
except ZeroDivisionError:
print('除数不能为0')
try:
#尝试执行下列代码
......
except(xxxx,yyyy):
#将两个（或多个）异常放在一起，只要触发其中一个，就执行所包含的代码。
......
try:
#尝试执行下列代码
......
except Exception:
#常规错误的基类，假设不想提供很精细的提示，可以用这个语句响应常规错误。
......
try:
#尝试执行下列代码
......
except BaseException:
#BaseException是Exception的父类
......
35 类
#类的定义-------------------
class Person:
eye = '2'
def say(self):
print('我有'+self.eye+'个眼睛')
#类名的首字母要大写
#方法的第一个参数必须为self，不可省略;调用方法时忽略self,无需传参数
#类的调用-------------------
xiaoming = Person()#实例化
print(xiaoming.eye)
xiaoming.say()
#self的含义-------------------
#self代表的是类的实例。
#当我们调用xiaoming.say()时，实际上Python解释成Person.say(xiaoming)，也就是说把self替换成类的实例。
#构造方法-------------------
#def __init__(self)
#初始化方法的作用在于：当每个实例对象创建时，该方法内的代码无须调用就会自动运行。
#一般用于类属性的赋值
#例如
class Chinese:
def __init__(self, name, birth, region):
self.name = name # self.name = '吴枫'
self.birth = birth # self.birth = '广东'
self.region = region # self.region = '深圳'
def born(self):
print(self.name + '出生在' + self.birth)
def live(self):
print(self.name + '居住在' + self.region)
person = Chinese('吴枫','广东','深圳') # 传入初始化方法的参数
person.born()
person.live()
#__str__()方法-----------------
#def __str__(self)
#作用：类中定义了__str__(self)方法，使用print打印实例对象时就会打印出此方法中return的数据
#此方法里必须有return 字符串
#直接打印对象时自动调用
#例如
class Book:
def __init__(self, name, author, comment, state = 0):
self.name = name
self.author = author
self.comment = comment
self.state = state
def __str__(self):
if self.state == 0:
status = '未借出'
else:
status = '已借出'
return '名称：《%s》 作者：%s 推荐语：%s\n状态：%s ' % (self.name, self.author, self.comment, status)
book1 = Book('像自由一样美丽','林达','你要用光明来定义黑暗，用黑暗来定义光明')
print(book1)
#类的继承
#语法
class A(B):
#例子
class Chinese:
eye = 'black'
def eat(self):
print('吃饭，选择用筷子。')
class Cantonese(Chinese):
pass # pass表示'跳过'，不执行其他操作
yewen = Cantonese()
print(yewen.eye)
yewen.eat()
#object，是所有类的父类(超类)，我们将其称为根类
#函数isinstance()，可以用来判断某个实例是否属于某个类。
print(isinstance(1,int)) #True
print(isinstance(1,str)) #False
# 判断实例是否属于元组里几个类中的一个
print(isinstance(1,(int,str))) #True
class Chinese:
pass
class Cantonese(Chinese):
pass
gonger = Chinese()
yewen = Cantonese()
print('\n验证1：子类创建的实例同时也属于父类')
print(isinstance(gonger,Chinese))
print(isinstance(yewen,Chinese))
print('\n验证2：父类创建的实例不属于子类。')
print(isinstance(gonger,Cantonese))
print('\n验证3：类创建的实例都属于根类。')
print(isinstance(gonger,object))
print(isinstance(yewen,object))
多层继承和多重继承
#多层继承(纵向)
class Earthman:
eye_number = 2
class Chinese(Earthman):
eye_color = 'black'
class Cantonese(Chinese):
pass
yewen = Cantonese()
print(yewen.eye_number)
print(yewen.eye_color)
#多重继承(横向)
class C0:
name = 'C0'
class C2(C0):
num = 2
class C1:
num = 1
class C3:
name = 'C3'
class C4(C1,C2,C3):
pass
ins = C4()
print(ins.name) # 打印出C0
print(ins.num) # 打印出1
#语法为class A(B,C,D):
#就近原则，越靠近子类（即越靠左）的父类，越亲近，越优先考虑。子类调用属性和方法时，会先在靠左的父类里找，找不到才往右找。
#若某父类还有父类的话，会先继续往上找到顶#类的定制
#1新增代码
#可以在子类下新建属性或方法，让子类可以用上父类所没有的属性或方法
class Chinese:
eye = 'black'
def eat(self):
print('吃饭，选择用筷子。')
class Cantonese(Chinese):
native_place = 'guangdong'
def dialect(self):
print('我们会讲广东话。')
yewen = Cantonese()
print(yewen.eye)
print(yewen.native_place)
yewen.eat()
#2重写代码
class Chinese:
def __init__(self, greeting = '你好', place = '中国'):
self.greeting = greeting
self.place = place
def greet(self):
print('%s！欢迎来到%s。' % (self.greeting, self.place))
class Cantonese(Chinese):
def __init__(self, greeting = '雷猴', place = '广东'):
Chinese.__init__(self, greeting, place)
yewen = Cantonese()
yewen.greet()
36 二进制
计算机用二进制数来处理各种信息。二进制由0和1组成。
用来存放一位0或1，就是计算机里最小的存储单位，叫做【位】，也叫【比特】（bit）
我们规定8个比特构成一个【字节】（byte）。1 byte = 8 bit
37编码表
目的是用二进制数表示各种符号
一开始，是美国首先出台了ASCII编码，使用7个比特位（最多表示128位）表示数字，字母，其他字符，所以一个字节中被剩下的那个比特位就被默认为0。
编码表传入欧洲各国，才发现这128位不够用。就把最后一个比特位也编进来。由于各国语言不同，128到255这一段的解释就完全乱套了。
到中国后，一个字节的256位都被占满了，但中国有10万多个汉字，发明了GB2312编码，它用2个字节，也就是16个比特位，来表示绝大部分（65535个）常用汉字。后来，为了能显示更多的中文，又出台了GBK标准。
为了沟通的便利，Unicode（万国码）应运而生，这套编码表将世界上所有的符号都纳入其中。现在Unicode可以容纳100多万个符号。
但是！问题又来了。为迁就一些占用字节比较多的语言，英文也要跟着占两个字节。比如要存储A，原本00010001就可以了，现在偏得用两个字节：00000000 00010001才行，这样对计算机空间存储是种极大的浪费！
这时又发明了UTF-8。它是一种针对Unicode的可变长度字符编码，它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度，而当字符在ASCII码的范围时，就用一个字节表示，所以UTF-8还可以兼容ASCII编码。
Unicode与UTF-8这种暧昧的关系一言以蔽之：Unicode是内存编码的规范，而UTF-8是如何保存和传输Unicode的手段。
Python3当中，程序处理我们输入的字符串，是默认使用Unicode编码的
数据在内存当中处理时，使用的格式是Unicode，统一标准。
数据在硬盘上存储，或者是在网络上传输时，用的是UTF-8，因为节省空间。
38 encode()和decode()
print('张建树'.encode('utf-8'))
print('张建树'.encode('gbk'))
print(b'\xe5\xbc\xa0\xe5\xbb\xba\xe6\xa0\x91'.decode('utf-8'))
print(b'\xd5\xc5\xbd\xa8\xca\xf7'.decode('gbk'))
#输出
#b'\xe5\xbc\xa0\xe5\xbb\xba\xe6\xa0\x91'
#b'\xd5\xc5\xbd\xa8\xca\xf7'
#张建树
#张建树
#前面都有一个字母b，比如b'\xce\xe2\xb7\xe3'，代表它是bytes（字节）类型数据。
#可以用type()函数验证一下
print(type('张建树'))
print(type(b'\xe5\xbc\xa0\xe5\xbb\xba\xe6\xa0\x91'))
#输出
#
#
#\x为分隔符
39 文件读写
#文件读取
#打开
file = open('pthon文件读写示例文件.txt','r',encoding='utf-8')
#读
content = file.read()
print(content) #它会读成字符串的数据形式
#关闭
file.close()
#说明：
#open()第一个参数为文件路径，绝对路径或相对路径都行。
#open()第二个参数为打开文件的模式，r代表读，w代表写（覆盖原有内容），a代表追加（在原有内容上增加，不覆盖）
#open()第三个参数规定返回的数据采用哪种编码
#Windows系统里，常用\来表示绝对路径，/来表示相对路径
#但由于python转义字符\的存在，为了避坑，绝对路径可采用以下两种方式：
open('C:\\Users\\Ted\\Desktop\\test\\abc.txt')
open(r'C:\Users\Ted\Desktop\test\abc.txt')
#获取文件路径的窍门
#pycharm软件中，找到目标文件，右击，copy path，相对路径和绝对路径都可复制粘贴
#文件写入
#打开
file = open('D:/ZJS/fbtest/pthon文件读写示例文件.txt','w',encoding='utf-8')
#写入
file.write('222222')
#关闭
file.close()
#w会覆盖原有内容
#a会在原有内容上增加写入
#write()函数写入文本文件的也是字符串类型
#在'w'和'a'模式下，如果你打开的文件不存在，那么open()函数会自动帮你创建一个#关键字with可以避免忘记写文件关闭close()
# 普通写法
file1 = open('abc.txt','a')
file1.write('张无忌')
file1.close()
# 使用with关键字的写法
with open('abc.txt','a') as file1:
file1.write('张无忌')
如果想要写入音频和图片，我们可以看到里面有'wb'的模式，它的意思是以二进制的方式打开一个文件用于写入。因为图片和音频是以二进制的形式保存的，所以使用wb模式就好了
按行读取
#按行读取
readlines()
返回列表，每一行的内容为一个元素
write()和writelines()
write()的参数必须是一个字符串
而writelines()可以是序列，所以我们使用writelines()。
40 split()/join()
split(sep)是把字符串按指定符号sep进行分割的，而还有一个join()函数，是把字符串合并的。
a=['c','a','t']
b=''
print(b.join(a)) #cat
c='-'
print(c.join(a)) #c-a-t
#join()的用法是str.join(sequence)，str代表在这些字符串之中，你要用什么字符串连接，在这里两个例子，一个是空字符串，一个是横杠，sequence代表数据序列，在这里是列表a
41 格式化字符串
之前可以用print('%d%f%s' % (1,1.2,'abc'))
现在可以使用format()函数
print('{}，{}'.format(0,1)) # 不设置指定位置时，默认按顺序对应。0,1
print('{1}，{0}'.format(0,1)) # 优势2：当设置指定位置时，按指定的对应。1,0
42 模块&模块导入
模块是最高级别的程序组织单元。什么都可以封装，变量、函数、类等
更独特的是，定义变量需要用赋值语句，封装函数需要用def语句，封装类需要用class语句，但封装模块不需要任何语句。
单独的.py文件，本质上都是一个模块
封装模块的目的也是为了把程序代码和数据存放起来以便再次利用。如果封装成类和函数，主要还是便于自己调用，但封装了模块，我们不仅能自己使用，文件的方式也很容易共享给其他人使用。
使用模块主要有两种方式，一种是自己建立模块并使用，另外一种是使用他人共享的模块。
建立模块，其实就是在主程序的py文件中，使用import语句导入其他py文件。
使用import语句导入一个模块，主要的目是为了利用模块中已经封装好的变量、函数、类，而不是运行模块中的执行语句
#test.py
a = '我是模块中的变量a'
print(123) #注意此句
def hi():
a = '我是函数里的变量a'
print('函数“hi”已经运行！')
class Go2:
a = '我是类2中的变量a'
def do2(self):
print('函数“do2”已经运行！')#main.py
import test
print(test.a)
test.hi()
A = test.Go2()
print(A.a)
A.do2()
#输出
#123 #注意此句
#我是模块中的变量a
#函数“hi”已经运行！
#我是类2中的变量a
#函数“do2”已经运行！#import...as... 取别名
import test as t
print(t.a)
t.hi()
A = t.Go2()
print(A.a)
A.do2()#同时导入多个模块
import a,b,c# from...import...语句可以让你从模块中导入一个指定的部分到当前模块
#格式如下
from （模块名）import （指定模块中的变量名/函数名/类名）
#导入后的部分可直接使用，无需加“模块名.”的前缀
# 【文件：test.py】
def hi():
print('函数“hi”已经运行！')
# 【文件：main.py】
from test import hi
hi()
#当我们需要从模块中同时导入多个指定内容，也可以用逗号隔开，写成from xx模块 import a,b,c的形式。
# 【文件：test.py】
a = '我是模块中的变量a'
def hi():
a = '我是函数里的变量a'
print('函数“hi”已经运行！')
class Go2:
a = '我是类2中的变量a'
def do2(self):
print('函数“do2”已经运行！')
# 【文件：main.py】
from test import a,hi,Go2
print(a)
hi()
A = Go2()
print(A.a)
A.do2()
#对于from … import …语句要注意的是，没有被写在import后面的内容，将不会被导入。
#导入test中的所有部分
from test import *
43 if __name__ == '__main__'语句
如果XX.py文件中写了如下语句：
代码块1....
if __name__ == '__main__'：
代码块2....那么当此文件作为程序入口运行时，代码块1（如果有执行语句或者打印）和代码块2全部执行
XX.py文件作为模块是被其他程序导入时，代码块②不被运行
通常在主文件中使用，表示这是程序的入口
44.借用模块
系统内置模块，import方式借用。
模块名.__file__可以找到模块的文件路径。
使用dir()函数可以查看模块里面有什么变量、函数、类、类方法。x可以是模块，也可以是任意一种对象。
import random
print(random.__file__)#找到random模块的路径
print(dir(random))#查看模块下的东西
print(dir(random.Random))#查看random模块下的Random类下的东西
str = ''
print(dir(str))#列出字符串的相关
第三方模块，通过pip下载安装
45. CSV模块
#读
import csv
with open("test.csv",'r',newline = '',encoding='utf-8') as f:
reader = csv.reader(f)
for row in reader:
print(row)
print("读取完毕！")
#写
import csv
with open('test.csv','a/w', newline='',encoding='utf-8') as f:
writer = csv.writer(f)
writer.writerow(['4', '猫砂', '25', '1022', '886'])
writer.writerow(['5', '猫罐头', '18', '2234', '3121'])
writer.writerows([['5', '猫罐头', '18', '2234', '3121'],['5', '猫罐头', '18', '2234', '3121']])
46.python发邮件
import smtplib
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart
from email.header import Header
to_addrs = []
from_addr = input('请输入登录邮箱：')
password = input('请输入邮箱授权码：')
while True:
to_addr = input('请输入收件邮箱：')
to_addrs.append(to_addr)
choice = input('是否继续添加收件邮箱？结束请按q，继续请按任意键')
if choice == 'q':
break
server_host = '192.168.1.1'
server_port = '25'
msg_content = '这是由python代码发送的邮件'
msg = MIMEText(msg_content,'plain','utf-8')
msg['From'] = Header(from_addr)
msg['To'] = Header(','.join(to_addrs))
msg['Subject'] = Header('python email test')
server = smtplib.SMTP()
server.connect(server_host,server_port)
# server = smtplib.SMTP_SSL(server_host)
# server.connect(server_host,server_port)
server.login(from_addr,password)
try:
server.sendmail(from_addr,to_addr,msg.as_string())
print('恭喜，发送成功')
except:
print('发送失败，请重试')
server.quit()
47.制作动态二维码
from MyQR import myqr
myqr.run(
words='https://www.baidu.com/',
#扫描二维码后，显示的内容，或是跳转的链接
version=5,
#设置容错率。
level='H',
#控制纠错水平，范围是L、M、Q、H，从左到右依次升高
picture=r'D:\桌面\123.gif',
#图片所在目录，可以是动图
colorized=True,
#黑白(False)还是彩色(True)
contrast=1.0,
#用以调节图片的对比度，1.0 表示原始图片，更小的值表示更低对比度，更大反之。默认为1.0。
brightness=1.0,
#用来调节图片的亮度，用法同上。
save_name='Py.gif',)
#控制输出文件名，格式可以是 .jpg， .png ，.bmp ，.gif ；
48.三种方式求绝对值
import math
# 方法1，关键词：条件判断
def abs_value1(x):
if x>0:
return x
elif x<0:
return x*-1
else:
return 0
# 方法2，关键词：内置函数
def abs_value2(x):
return abs(x)
# 方法3，关键词：内置模块
def abs_value3(x):
return math.fabs(x)
# 写完3种方法后，验证一下吧。
print(abs_value1(0))
print(abs_value2(0))
print(abs_value3(0))