基础知识
标识符命名方式：
第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感，python3中可以用中文作为变量名。
注释：
单行注释以 # 开头
多行注释可以用多个 # 号，还有 ''' 和 """。
缩进：
Python是使用缩进来表示代码块，不需要使用大括号 {} ，缩进错误会导致运行出错。
多行语句：
Python编写时如果语句很长，一行不能写完，我们可以在第一行末尾使用反斜杠 \ 来实现多行语，但在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \
Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割
字符串的输出方法：
str='123456789'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始后的所有字符
print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
转义字符：
print('\n') # 输出空行
print(r'\n') # 输出 \n
\ 续行符 \\ 反斜杠符 \”双引号 \a 响铃：执行后电脑有响声 \b 退格 \000 空 \v纵向制表符 \t 横向制表符
\f 换页 \yyy 八进制数，y 代表 0~7 的字符,例：\012为换行 \xyy 十六进制数，以 \x 开头，y 代表的字符，例：\x0a为换行
等待用户输入：
input("请输入用户名：\n ")
print输出：
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
print( x, end=" " )
导入：
在 python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
删除对象：
del var
del var1, var2
List（列表）：
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
列表中的元素是可以改变的：
a = [1, 2, 3, 4, 5, 6]
a[0] = 9
a[2:5] = [13, 14, 15]
a[2:5] = []
第三个参数为补偿，负数表示从后往前读取
inputWords[-1::-1]
可使用append()方法添加列表，如a.append(7)
列表拼接：
squares = [1, 4, 9, 16, 25]
squares += [36, 49, 64, 81, 100]
输出squares：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
列表嵌套：
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n] # x输出结果： [['a', 'b', 'c'], [1, 2, 3]]
x[0] #输出结果：['a', 'b', 'c']
x[0][1] #输出结果：b
Tuple（元组）：
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组
元祖的截取方法与列表一致
特殊规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合：
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print (tup3) 输出结果：(12, 34.56, 'abc', 'xyz')
元组内置函数：
len(元组名) 计算元祖元素个数
max(元组名) 返回元组中元素最大值。
min(元组名) 返回元组中元素最小值。
tuple(iterable) 将可迭代系列转换为元组
Set（集合）：
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典的。
parame = {value01,value02,...}
或者set(value)
set可以进行集合运算：
a = set('abracadabra')
b = set('alacazam')
print(a) #a集合输出时会去重。输出结果{'b', 'c', 'a', 'r', 'd'}
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
添加元素：s.add( x )
s.update( x ) 这个方法，也可以添加元素，且参数可以是列表，元组，字典等，x 可以有多个，用逗号分开。
移除集合中的元素：s.discard( x )
s.pop() 可随机删除集合中的一个元素
Dictionary（字典）：
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
清空字典：dict.clear()
字典内置函数：
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典，可以打印的字符串表示。
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
Python 字符串格式化：
| %c | 格式化字符及其ASCII码 | %f | 格式化浮点数字，可指定小数点后的精度 | ||
| %s | 格式化字符串 | %e | 用科学计数法格式化浮点数 | ||
| %d | 格式化整数 | %E | 作用同%e，用科学计数法格式化浮点数 | ||
| %u | 格式化无符号整型 | %g | %f和%e的简写 | ||
| %o | 格式化无符号八进制数 | %G | %f 和 %E 的简写 | ||
| %x | 格式化无符号十六进制数 | %p | 用十六进制数格式化变量的地 | ||
| %X | 格式化无符号十六进制数（大写） | ||||
f-string：
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串
name = 'Runoob'
print('Hello %s' % name)
print(f'Hello {name}') #两种输出方式结果相同
w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print(f'{w["name"]}: {w["url"]}') #输出结果为Runoob: www.runoob.com
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
x = 1
print(f'{x+1=}') # 输出结果为：x+1=2
if语句
Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
if嵌套
在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。
while循环
while 判断条件(condition)：
执行语句(statements)……
while 循环使用 else 语句：如果 while 后面的条件语句为 false 时，则执行 else 的语句块。
while <expr>:
<statement(s)>
else:
<additional_statement(s)>
for循环
for循环可以遍历任何可迭代对象，如一个列表或者一个字符串。
for <variable> in <sequence>:
<statements>
else:
<statements>
range()函数
如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:
for i in range(5):
print(i)
它会生成5以内数字的一个数列
range(5,9) 指定区间
range(0,10,3) 0到10之间，步长为3
可以结合range()和len()函数以遍历一个序列的索引：
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
print(i, a[i])
输出结果 ：
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
可以使用range()函数来创建一个列表：
list(range(5))
结果为：[0, 1, 2, 3, 4]
break与continue
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
pass 语句
pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句
迭代器
迭代器是一个可以记住遍历的位置的对象，迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退。迭代器有两个基本的方法：iter() 和 next()，字符串，列表或元组对象都可用于创建迭代器。
函数
def 函数名（参数列表）:
函数体
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
加了两个星号 ** 的参数会以字典的形式导入。
声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 * 后的参数必须用关键字传入。
匿名函数
lambda [arg1 [,arg2,.....argn]]:expression
例：
sum = lambda arg1, arg2: arg1 + arg2
print ("相加后的值为 : ", sum( 10, 20 ))
renturn语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
def sum( arg1, arg2 ):
total = arg1 + arg2
print ("函数内 : ", total)
return total
#调用
total = sum( 10, 20 )
print ("函数外 : ", total)
列表推导式
将列表中每个数值乘三，获得一个新的列表
vec = [2, 4, 6]
[3*x for x in vec] 结果为：[6, 12, 18]
[[x, x**2] for x in vec] 结果为：[[2, 4], [4, 16], [6, 36]]
可以用 if 子句作为过滤器
[3*x for x in vec if x > 3] 结果为：[12, 18]
关于循环和其它技巧的演示
vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
[x*y for x in vec1 for y in vec2] 结果为：[8, 6, -18, 16, 12, -36, 24, 18, -54]
[vec1[i]*vec2[i] for i in range(len(vec1))] 结果为：[8, 12, -54]
将3X4的矩阵列表转换为4X3列表
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
[[row[i] for row in matrix] for i in range(4)] 结果为：[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
构造函数 dict() 直接从键值对元组列表中构建字典
dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) 结果为：{'sape': 4139, 'jack': 4098, 'guido': 4127}
字典推导可以用来创建任意键和值的表达式词典：
{x: x**2 for x in (2, 4, 6)} 结果为：{2: 4, 4: 16, 6: 36}
如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便
dict(sape=4139, guido=4127, jack=4098) 结果为：{'sape': 4139, 'jack': 4098, 'guido': 4127}
模块引入
想在demo01.py内引入demo02模块，在demo01模块顶端加上：“import demo02“，一个模块只会被导入一次，不管你执行了多少次import
from … import 语句，要导入模块 fibo 的 fib 函数：
from fibo import fib
from … import * 语句，把一个模块的所有内容全都导入到当前的命名空间
from modname import *
__name__属性：一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
dir()函数
内置的函数 dir() 可以找到模块内定义的所有名称，如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:
例：dir(fibo)
包
目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，最简单的情况，放一个空的 :file:__init__.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。
导入包里的特定模块：
第一种方法：import sound.effects.echo
访问：sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
第二种方法；from sound.effects import echo
访问：echo.echofilter(input, output, delay=0.7, atten=4)
第三种方法：from sound.effects.echo import echofilter
访问：echofilter(input, output, delay=0.7, atten=4)
类
用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。
类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
class MyClass:
i = 12345
def f(self):
return 'hello world'
使用
x = MyClass()
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
class people:
name = ''
age = 0
__weight = 0
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))
p = people('runoob',10,30)
p.speak() 输出：runoob 说: 我 10 岁。
继承
子类会继承父类的属性和方法。
单继承：
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak() 输出：ken 说: 我 10 岁了，我在读 3 年级
多继承：
#另一个类，多重继承之前的准备
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多重继承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默认调用的是在括号中排前地父类的方法 输出：我叫 Tim，我是一个演说家，我演讲的主题是 Python
方法重写：
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
重写了myMethed方法。
类的私有方法：
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。
File文件
open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。 open(file, mode='r')
file: 必需，文件路径（相对或者绝对路径）
mode: 可选，文件打开模式
mode 参数有：
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（Python 3 不支持）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
默认为文本模式，如果要以二进制模式打开，加上 b 。
关闭文件。关闭后文件不能再进行读写操作。
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
如果文件连接到一个终端设备返回 True，否则返回 False。
Python 3 中的 File 对象不支持 next() 方法。
返回文件下一行。
从文件读取指定的字节数，如果未给定或为负则读取所有。
读取整行，包括 "\n" 字符。
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
移动文件读取指针到指定位置
返回文件当前位置。
从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
将字符串写入文件，返回的是写入的字符长度。
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
python批量处理图片
pillow库：Pillow是Python里的图像处理库，提供了了广泛的文件格式支持，强大的图像处理能力，主要包括图像储存、图像显示、格式转换以及基本的图像处理操作等；
安装：pip install pillow
Image类：
导入：from PIL import Image
要从文件加载图像可以使用Image类中的open()函数：Image.open(fp, mode ='r' )，如果加载成功则会返回一个Image对象，fp是图片路径，mode是模式。图像的对象属性有filename源文件的文件名或路径、format图片的格式、size图片大小，以像素为单位、mode图片模式、width图像宽度、height图像高度、palette调色板表等；
im = Image.open('./Picture/image.jpeg')
# 获取图片的格式，大小，以及模式
print(im.format, im.size, im.mode)
save(fp, format=None, **params)：保存图像到给定的文件名下，如果没有指定格式则可以使用文件扩展名来确定要使用的格式，无返回值。fp是文件名或路径，format可选的格式覆盖；
thumbnail(size, resample=3)：指定图片的像素，size是大小，resample是重采样滤波器，可以是Image.NEAREST、Image.BILINEAR、Image.BICUBIC或者Image.LANCZOS，默认为Image.BICUBIC；
# 指定图片的像素
im.thumbnail((300, 600))
im.save('./Picture/image_128_128.jpg')
rotate(angle, resample=0, expand=0, ceter=None, translate=None)：旋转图片的方向，返回旋转后的图像副本，一个Image对象 。angle角度，为正数时，逆时针旋转，负数顺时针旋转，resample重采样滤波器、expand是否展开、center旋转中心、translate旋转后；
# 旋转图片的方向
dest_im = im.rotate(-30)
filter(filter)：给图片添加滤镜，返回一个Image对象，filter是过滤器；
# 给图片添加滤镜
dest_im = im.filter(ImageFilter.GaussianBlur)
transpose(method)：旋转或翻转图像，返回旋转或翻转后的图像副本，一个Image对象。method可以是Image.FLIP_LEFT_RIGHT、Image.FLIP_TOP_BOTTOM、Image.ROTATE_90、Image.ROTATE_180、Image.ROTATE_270、Image.TRANSPOSE或者Image.TRANSVERSE；
# 图片反转
dest_im = im.transpose(Image.FLIP_LEFT_RIGHT) # 左右反转
dest_im = im.transpose(Image.FLIP_TOP_BOTTOM) # 上下反转
show()：显示这个图像，此方法主要用于调试目的；
ImageDraw模块：ImageDraw模块为Image对象提供简单的2D图形，可以使用此模块创建新图像，注释或润饰现有图像，以及动态生成图形以供Web使用；
ImageDraw.Draw（im,mode=None)：创建可用于在给定图像中绘制的对象，im要绘制的图像、mode 用于颜色值的可选模式；
ImageDraw.text(xy，text，fill=None，font=None，anchor=None，spacing=0，align =“left”，direction = None，features=None，language=None)：在给定位置绘制字符串，xy文本的左上角、text要绘制的文本、fill用于文本的颜色、direction文字的方向、language文字的语言；
ImageDraw.point（xy,fill=None）：在给定坐标处绘制点，xy元组的序列或类似的数值、fill用于点的颜色；
# 图片上写文字
image = Image.open('./Picture/image.jpeg')
img_draw = ImageDraw.Draw(image)
img_draw.text((200, 250), 'hello world', fill='blue') # 放上文字信息到图像上
image.show()
扫一扫
2166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
