Python

By AdStation | July 4th, 2022 | Categories: Z-Notes
Python

一、基础知识

1. “方法”是Python可对数据执行的操作。

如:

name=”ada lovelace”

print(name.title())

在name.title()中,name后面的句点(.),让Python对变量name执行方法title()指定的操作。

title()以首字母大写的方式显示每个单词。

upper()将字符串全部改为大写。

lower()将字符串全部改为小写。

rstrip()将字符串输出末尾中(右侧,right)的空白删除,但实际并不删除变量末尾中的空白。

lstrip()将字符串输出开头中(左侧,left)的空白删除,但实际并不删除变量开头中的空白。

strip()将字符串输出两侧中的空白删除,但实际并不删除变量两侧中的空白。

2. Python使用加号(+)来合并字符串,这种合并字符串的方法称为拼接

如:

first_name=”jack”

last_name=”wong”

full_name=first_name+” ”+last_name

print(“Hello, ”+full_name.title()+”!”)

3. print(),字符串用引号括起,可用单引号或双引号。

4. 空白泛指任何非打印字符,如空格、制表符和换行符。

制表符:\t

换行符:\n

5.在Python中,可对整数执行加(+)减(-)乘(*)除(/)运算,使用两个乘号(**)表示乘方运算(如,5**3,表示5的3次方)。

Python支持运算次序,和数学运算次序一样,使用括号()提升运算优先级,例如(2+3)*5。

空格不影响Python计算表达式的执行。

6.Python将带小数点的数字都称为浮点数。

7.函数str(),可以将非字符串值表示为字符串。

如:

age=23

message="Happy "+str(age)+"rd Birthday!"

print(message)

8.Python中的代码注释:注释用井号(#)标识,井号后面的内容都会被Python解释器忽略。

9.列表:由一系列按特定顺序排列的元素组成(即,有序集合),用方括号([])表示列表,并用逗号来分隔其中的元素。(其中,引号可以用单引号也可以用双引号,但是编译后print输出都是单引号表示,应优先使用单引号。)

如:

name=[‘Jack’,‘Rose’,‘Edward’,‘John’]

print(name)

编译后会输出以下内容(带方括号和单引号):

['Jack', 'Rose', 'Edward', 'John']

访问列表元素,字符串方法运算符可以直接调用到列表元素的访问中,元素索引序号从0递增,并且Python为访问最后一个列表元素提供了一种特殊的语法(通过将索引指定为-1,可以让Python返回最后一个列表元素,-2为倒二个,-3为倒三个,以此类推)。如:

name=[‘Jack’,‘Rose’,‘Edward’,‘John’]

print(name[0].lower())

print(name[-1])

print("Hello "+name[0])

编译后输出(不带方括号和单引号):

jack

John

Hello Jack

10.要修改列表元素,可指定列表名和要修改的元素的索引,再指定该元素的新值。

如:

name=[‘Jack’,‘Rose’,‘Edward’,‘John’]

name[0]='William'

print(name)

会输出:

['William','Rose','Edward','John']

11.方法append()将可以将新元素添加到列表末尾,不影响列表中的其他所有元素,且一次只能添加一个。

如:

motorcycles=['honda','yamaha','suzuki']

print(motorcycles)

motorcycles.append('ducati')

print(motorcycles)

12.方法insert()可在列表的任何位置添加新元素。

如:

motorcycles=['honda','yamaha','suzuki']

print(motorcycles)

motorcycles.insert(0,'ducati')

print(motorcycles)

将输出(现有元素右移一个位置):

['honda', 'yamaha', 'suzuki']

['ducati', 'honda', 'yamaha', 'suzuki']

13.删除列表中的元素:

①使用del语句删除,前提是要知道删除元素的位置序列。

如下:

motorcycles=['honda','yamaha','suzuki']

print(motorcycles)

del motorcycles[1]

print(motorcycles)

编译后输出:

['honda', 'yamaha', 'suzuki']

['honda', 'suzuki']

②使用方法pop()可删除列表的元素,并能接着使用它。在括号中输入元素的位置序列,即可以删除对应序列位置的元素,括号放空,默认删除最后一个元素。

如:

motorcycles=['honda','yamaha','suzuki']

print(motorcycles)

popped_motorcycle=motorcycles.pop(0)

print(motorcycles)

print(popped_motorcycle)

编译后输出:

['honda', 'yamaha', 'suzuki']

['yamaha', 'suzuki']

honda

③使用方法remove()可以根据元素的值,删除列表元素。(在不知道元素的位置序列情况下)

注意:方法remove()只删除第一个指定的值,如果要删除的值在列表中出现多次,就需要使用循环判断是否删除了所有这样的值。

如(单个删除):

motorcycles=['honda','yamaha','suzuki','ducati']

print(motorcycles)

motorcycles.remove('ducati')

print(motorcycles)

编译后,输出:

['honda', 'yamaha', 'suzuki', 'ducati']

['honda', 'yamaha', 'suzuki']

如(循环删除):

pets = ['dog', 'cat', 'rabbit', 'cat']

print(pets)

while 'cat' in pets:

pets.remove('cat')

print(pets)

编译后,输出:

['dog', 'cat', 'rabbit', 'cat']

['dog', 'rabbit']

14.使用方法sort()可以永久性地修改列表元素的排列顺序,使元素按照字母顺序排列。

使用传递参数reverse=True, 可以使元素按照字母反序排列。

如:

carts = ['bmw', 'audi', 'toyota', 'subaru']

carts.sort()

print(carts)

carts.sort(reverse=True)

print(carts)

编译后,输出:

['audi', 'bmw', 'subaru', 'toyota']

['toyota', 'subaru', 'bmw', 'audi']

15.使用函数sorted()可以按特定顺序显示列表元素,同时不影响元素在列表中的原始排列顺序,非永久性。函数sorted()可以按照元素字母顺序进行临时排序,加入传递参数sorted(list_name, reverse=True)按照字母反序排序。

如:

cars = ['bmw', 'audi', 'toyota', 'subaru']

print("Here is the original list:")

print(cars)

print('Here is the sorted list:')

print(sorted(cars))

print("Here is the reverse-sorted list:")

print(sorted(cars, reverse=True))

print("Here is the original list again")

print(cars)

编译后,输出:

Here is the original list:

['bmw', 'audi', 'toyota', 'subaru']

Here is the sorted list:

['audi', 'bmw', 'subaru', 'toyota']

Here is the reverse-sorted list:

['toyota', 'subaru', 'bmw', 'audi']

Here is the original list again

['bmw', 'audi', 'toyota', 'subaru']

16.使用方法reverse()可以使列表元素按照原来的顺序,永久性地反向进行排列。

使用函数len()可以快速地获取列表的长度,即元素的个数(注意与元素序列数字的区别,长度计数从1开始,不是0)。

17.列表中的元素顺序,叫索引

18.Python中的for循环本行要加冒号(:),循环后的缩进部分(使用一个\t符,pycharm编译器自动缩进4格),会一直执行循环。格式如下:

for xxx in xxx:

xxx

如:

magicians = ['alice', 'david', 'corolina']

for magician in magicians:

print(magician)

编译后,输出:

alice

david

corolina

19.使用函数range(n, m, x)可以生成n,n+x, n+x+x, ...., m-1(可能不存在输出m-1)的数字,其中n<m, x为步长,x放空则步长默认为1;n,x放空,只有m,表示生成m个数值(如range(30),生成30个变量)。

如:

for value in range(1, 5, 2):

print(value)

编译后,输出:

1

3

20.使用函数list()可以将获取的值,按照获取顺序生成列表。

如:

numbers = list(range(1, 5, 2))

print(numbers)

编译后,输出:

[1, 3]

21.使用函数min()、max()、sum()可以找出列表中的最小值、最大值和总和。

如:

digits = ['1', '2', '3', '4']

min(digits)

22.列表解析

如:

square = [value**2 for value in range(1, 11, 1)] # 注意结构(列表名=[变量表达式 for 变量 in 表达式]

print(square)

编译后,输出:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

23.Python切片:选中列表中的一部分元素,格式:list_sample[n:m],其中n≤m(相等时输出空白列表),表示调用列表list_sample中的第n-1至第m之间的元素,若切片中没有指定第一个索引n,Python默认为从列表开头开始,若切片中没有指定第二个索引m,Python默认为调用至列表末尾最后一个元素,两个都放空则表示整个列表list_name[:]。

(备注:对于字符串类型变量使用切片,string_name[n:m],作用是切出第n到第m个字符之间的内容。)

如:

player = ['jack', 'kuka', 'michael', 'eli']

print(player[0:3])

编译后,输出:

['jack', 'kuka', 'michael']

遍历切片,如:

players = ['charles', 'martina', 'michael', 'florence', 'eli']

print("Here are the first three players on my team:")

for player in players[0:3]:

print(player.title())

编译后,输出:

Here are the first three players on my team:

Charles

Martina

Michael

list1=list与list2=list[:]的区别:list1=list是把list1指向list,并没有在内存上单独为list1创建列表,对list1或list使用方法或者函数,都会改变同一列表;list2=list[:],在内存上单独为list2创建列表,并将list得切片部分元素复制到list2,对list2或list使用方法或者函数,只会单独改动一个列表。

24. Python将不能修改的值称为不可变的,即所指向的内存中的内容不可变,而不可变的列表被称为元组

元组看起来犹如列表, 但是使用圆括号而不是方括号来标识(tuple(1, 2 ,3)),定义元组后,就可以使用索引来访问其元素(tuple[0]),就像访问列表元素一样。

元组中只包含一个元素时,需要在元素后面添加逗号(,),如:tuple(1,),否则括号会被当作运算符使用。

元组不可变指的是不可以改变元组所指向的内存内容(元组内的元素值),但是可以通过改变元组所指向的内存地址,不同内存地址储存不同的内容(即元素集合),来修改元组的变量(储存元组的变量)。

如:

dimensions = (200, 50)

print(dimensions[0])

print(dimensions[1])

for dimension in dimensions:

print(dimension)

dimensions = (100, 25)

print(dimensions)

dimensions = ('length', 'width')

print(dimensions)

编译后,输出:

200

50

200

50

(100, 25)

('length', 'width')

25.相等运算符(==)对两边的值是否相等进行判断,相等时返回True,不相等时返回False。

不等运算符(!=)判断两边的值是否不相等,不相等时返回True,相等时返回False。

数学比较:小于(<)、小于等于(<=)、大于(>)、大于等于(>=),可以直接应用到Python中进行条件判断。

关键字(and):逻辑与,格式:条件A and 条件B, 条件A和条件B都成立时,返回Ture,条件A和条件B其中一个不成立或者都不成立,返回False。可以进行多个条件检查。

关键字(or):逻辑或,格式:条件A or 条件B,条件A和条件B其中一个成立或者都成立时,返回True,都不成立时返回False。可以进行多个条件检查。

关键字(in):格式:变量A in 列表B,列表B中元素包含A则返回Ture, 列表B中元素不包含A则返回False。

关键字(not in):格式:变量A not in 列表B,列表B中元素不包含A则返回Ture, 列表B中元素包含A则返回False。

布尔表达式:条件测试的别名,结果要么为True,要么为False。(Python将非空字符串、非空列表解释为True)

26.Python中的if循环:常用的结构有if结构、if-else结构、if-elif(一个或多个)-else结构、if-elif结构、if-if(一个或多个)结构

27.Python常见的数据类型

int  整型

float  浮点型

bool  布尔型

str  字符型

list  列表

tuple  元组

dict  字典

set  集合

complex  复数

28.在if语句中,将列表名用在条件表达式中时,Python将在列表至少包含一个元素时返回True,并在列表为空时返回False。

29.在Python中,字典是一系列键-值对,每个键都与一个值相关联,可以用键来访问与之关联的值,键和值之间用冒号分隔,键-值对之间用逗号分隔,值可以是数字、字符串、列表乃至字典。

格式: dict = {‘key1’:'value1', 'key2': value2, }

访问字典中的值:可以依次指定字典名和放在方括号内的键。

格式:dict['key']

添加键-值对:字典是一种动态结构,可随时在其中添加键-值对。要添加键-值对,可依次指定字典名、用方括号括起的键和相关联的值。

注意:键-值对的排列顺序与添加顺序不同,Python并不关心键-值对的添加顺序,而只关心键和值之间的关联关系。

格式:dict['key'] = value

如:

alien_0 = {'color': 'green', 'p oints': 5, }

print(alien_0)

alien_0['x_position'] = 0

alien_0['y_position'] = 25

print(alien_0)

编译后,输出:

{'color': 'green', 'points': 5}

{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}

修改字典中的值:可依次指定字典名,用方括号括起的键以及与改键相关联的新值。

格式:dict['key'] = new_value

删除键-值对:对于字典中不在需要的信息,可使用del语句将相应的键-值对彻底删除。使用del语句时,必须指定字典名和要删除的键。

格式:del dict['key']

遍历字典:使用for循环进行遍历+方法items()。要编写用于遍历字典的for循环,可以声明两个变量,用于储存键-值对中的键和值。对于这两个变量,可以使用任何名称。方法items()可以返回一个键-值对列表。(注意:即便遍历字典时,键-值对的返回顺序也与存储顺序不同。Python不关心键-值对的存储顺序,而只跟踪键和值之间的关联关系。)

格式:for key, value in dict.items():

遍历字典中的所有键:使用方法keys(),可以返回一个列表,其中包含字典中的所有键。(注意:遍历字典时,会默认遍历并返回所有的键,因此,如果将以下代码中的for name in favorite_languages.keys():替换为for name in favorite_languages,输出将不变。但是如果显式地使用方法keys(),可以让代码更容易理解。)

如:

favorite_languages = {'jen': 'python',

'sarah': 'c',

'edward': 'ruby',

'phil': 'python',

}

for name in favorite_languages.keys():

print(name.title())

编译后,输出:

Jen

Sarah

Edward

Phil

按顺序遍历字典中的所有键:使用函数sorted()和方法keys(),按照字母顺序输出键。

格式: for key in sorted(dict.keys())

遍历字典中的所有值:使用方法values(),可以返回一个列表,其中包含字典中的所有值。

如:

favorite_languages = {'jen': 'python',

'sarah': 'c',

'edward': 'ruby',

'phil': 'python',

}

print("The following languages have been mentioned:")

for language in favorite_languages.values():

print(language.title())

编译后,输出:

The following languages have been mentioned:

Python

C

Ruby

Python

30.集合(set)类似于列表,但每个元素都必须是独一无二,使用大括号({})将元素括在内。通过对包含重复元素的列表调用方法set(),让Python找出列表中独一无二的元素,并使用这些元素来创建一个集合。

如:

favorite_languages_dict = {'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', }

unique_languages_dict = set(favorite_languages_dict.values())

print(unique_languages_dict)

favorite_languages_list = ['python', 'c', 'ruby', 'python']

unique_languages_list = set(favorite_languages_list)

print(unique_languages_list)

编译后,输出:

{'c', 'ruby', 'python'}

{'c', 'ruby', 'python'}

31.嵌套:将一系列字典存储在列表中,或者将里列表作为值存储在字典中,这称为嵌套。可以在列表中嵌套字典、在字典中嵌套列表、字典中嵌套字典。(注意:列表和字典的嵌套层级不应太多。如果嵌套层级太多,应该使用其它方法。)

列表中嵌套字典格式: list = [{'a': 'b', 'c': d}, {'a': 'b', 'c': d}, {'a': 'b', 'c': d}]

字典中嵌套列表格式:dict = {'a': ['b', 'c', 'd'], 'e': [f, g, h], 'i': ['j', 'k', 'l']}

字典中嵌套字典格式:dict = { 'a': {'b': 'c', 'd': 'e', 'f': 'g', }, 'h': {'i': j, 'k': l, 'm': n, }, }

32.函数input()让程序暂停运行,等待用户输入一些文本。获取用户输入后,Python可以将其储存在一个变量中,以便后续使用。同时,函数input()接收一个参数(可以是直接的字符串,也可以是指向字符串的变量),即要向用户显示的提示或说明,让用户知道该如何做。Python将用户输入的内容解读为字符串。

如:

name = input("Please input your name.")

print(name)

33.运算符+=: 可以用于数值变量计算,也可以用于字符型变量拼接。

如:

prompt = "if you teel us who you are, we can personalize the messages you see."

prompt += "\nWhat is your fist name? "

name = input(prompt)

print("\nHello, " + name + "!")

编译后,输出:

if you teel us who you are, we can personalize the messages you see.

What is your fist name? Jack

Hello, Jack!

34.函数int(),它让Python将输入视为数值,即将数字的字符串表示转换为数值表示。

格式:value = int(str)

35.求模运算符%,将两个数相除并返回余数。

36.while循环:满足条件时,一直对循环内容进行循环,未满足条件,停止循环。

格式:

while 条件/布尔表达式:

循环内容

37.标志:在要求多个条件都满足才继续运行的程序中,可定义一个变量,用于判断整个程序是否处于活动状态。这个变量被成为标志。可以让程序在标志为True时继续运行,并在任何事件导致标志的值为False时让程序停止运行。

如:

prompt = "\nTell me something, and I will repeat it back to you:"

prompt += "\nEnter 'quit' to end the program. "

active = True

while active:

message = input(prompt)

if message == 'quit':

active = False

else:

print(message)

38.使用break退出循环:要立即退出while循环,不再运行循环中余下的代码,也不管条件测试的结果如果,可使用break语句。(注意:在任何Python循环中都可以使用break语句,例如,可使用break语句来退出遍历列表或字典的for循环。)

格式:

while 条件/布尔表达式:

循环内容

break

39.在循环中使用continue:可以使循环运行到continue时,直接返回开头(例如可以根据条件测试结果决定是否继续执行循环)

格式:

while 条件/布尔表达式:

循环内容

if 条件:

continue

循环内容

40.函数:带名字的代码块,用于完成具体的工作,要么返回预期的值,要么返回None。

函数定义:使用关键字def来告诉Python定义的函数,指出函数名,还可能在括号内指出函数为完成其任务需要什么样的信息,即形参定义以冒号结尾。定义后面的所有缩进行构成了函数体,用三引号括起的部分被称为文档字符串(docstring),描述了函数的具体功能,Python使用文档字符串来生成有关程序中函数的文档。

函数调用:让Python执行函数的代码。要调用函数,可依次指定函数名以及用括号括起的必要信息(即实参,实参是调用函数时传递给函数的信息,实参为字符串时,最好使用单引号,而不是双引号,实参可以是字符串、列表、字典、数值等)。可以根据需要调用函数任意次。

如:

def greet_user(username):

"""显示简单的问候语"""

print("Hello, " + username.title() + "!")

greet_user('jesse')

编译后,输出:

Hello, Jesse!

41.传递实参:像函数传递实参的方式有很多,可使用位置实参(基于是实参的顺序),这要求实参的顺序与形参的顺序相同,也可使用关键词实参(传递给函数的名称-值对,将名称和值关联起来,无需考虑实参的顺序),其中每个实参都由变量名和值组成,还可以用列表和字典。

(注意:将列表传递给函数后,函数就可以对其进行修改,函数对这个列表所做的任何修改都是永久性的。有时候,需要禁止函数修改列表,可以使用切片[n:m]创建列表副本,格式:function_name(list_name[:])。

默认值:定义函数时,给形参指定默认值,如def function(a, b='c'),在调用函数时,若给形参都提供了实参时,Python将使用指定的实参值,否则,将使用形参的默认值。(注意:使用默认值时,在形参列表中必须先列出没有默认值的形参,再列出有默认值的实参。这让Python依能够正确地解读位置实参)。

42.返回值:函数并非总是直接显示输出,相反,它可以处理一些数据,并返回一个或一组值。函数返回的值被称为返回值,函数可以返回任何类型的值,包括列表和字典等较复杂的数据结构。在函数中,可使用return语句将值返回到调用函数的代码行。返回值能够将程序的大部分繁重工作移到函数中去完成,从而简化程序。

如:

def get_formatted_name(first_name, last_name):

"""返回整洁的姓名"""

full_name = first_name + " " + last_name

return full_name.title()

musician = get_formatted_name('jimi', 'hendrix')

print(musician)

43.在函数定义的参数前添加一个星号(*),格式:def function_name(*formal_parameter),Python会创建一个名为formal_parameter的空元组(tuple),并将收到的所有值都封装到这个元组中,使函数可以接收任意数量的实参。

如果要让函数接收不同类型的实参,必须在函数定义中将接纳任意数量实参的形参放在最后,Python先匹配位置实参和关键字实参,再将余下的实参都收集到最后一个形参中。

如:

def make_pizza(size, *toppings):

"""概述要制作的比萨"""

print("\nMaking a " + str(size) + "-inch pizza with the following toppings: ")

for topping in toppings:

print("- " + topping)

make_pizza(16, 'pepperoni')

make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

编译后,输出:

Making a 16-inch pizza with the following toppings:

- pepperoni

Making a 12-inch pizza with the following toppings:

- mushrooms

- green peppers

- extra cheese

44.在函数定义的参数前添加两个星号(**),格式:def function_name(**formal_parameter),Python会创建一个名为formal_parameter的空字典(dict),并将收到的所有名称-值对(如:a=b)都封装到这个字典中,并且函数可以像访问其他字典那样访问该字典。

如:

def build_profile(first, last, **user_info):

"""创建一个字典,其中包含我们知道的有关用户的一切"""

profile = {'fist_name': first, 'last_name': last}

for key, value in user_info.items():

profile[key] = value

return profile

user_profile = build_profile('albert', 'einstein', location='princeton', field='physics')

print(user_profile)

编译后,输出:

{'fist_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}

45.将函数存储在模块中,即模块是扩展名为.py的文件,包含要导入到程序中的代码。

1) import语句允许在当前运行的程序文件中使用模块中的代码。

如:建立一个模块文件的前提下(module_name.py),通过import将该模块导入到要运行的程序中,并将其中的所有函数都复制到这个程序中(复制过程不可见,仅在运行缓存中后台复制),至此,程序可以调用被导入的模块中所有的函数。要调用被导入的模块中的函数,可指定导入的模板的名称module_name和函数名function_name(),并用句点分隔它们,格式:module_name.function_name()。

在module_name.py中:

def function_name(formal_parameters):

函数内容

在运行程序running_program中(格式):

import module_name

module_name.function_name(actual_parameters)

2) 导入特定的函数,格式:from module_name import function_name,通过用逗号分隔函数名,可根据需要从模块中导入任意数量的函数:from module_name import function_0, funtion_1, function_2 。若使用这种语法,调用函数时就无需使用句点,由于在import语句中显式地导入了函数,因此调用该函数时,只需指定其名称。

3)使用as给函数指定别名,如果要导入的函数名称可能与程序中现有的函数名称冲突,或者函数名字太长,可以使用关键字as为函数指定另一个名称,格式:from module_name import function_name as function_new_name。

4)使用as给模块指定别名,格式:import module_name as module_new_name,在调用模块中的函数时,可以用格式:module_new_name.funiction_name(actual_parameters)。别名的合理应用可以使代码更加简洁。

5)使用星号运算符(*)可以让Python导入模板中的所有函数,格式:from module_name import *。

注意:所有的import语句都应放在文件开头,唯一例外的情形是,在文件开头使用了注释(如,文档字符串)来描述整个程序。

46.根据约定,在Python中,首字母大写的名称指的是类(class),类的命名,创建类的代码格式:class class_name(),编写类时,定义一大类对象都有的通用行为,基于类创建对象时,每个对象都自动具备这种通用行为,然后可根据需要赋予每个对象独特的个性。根据类来创建对象被称为实例化,生成可以的使用的类的实例(instance),可以将类视为有关如何创建实例的说明。类中的函数称为方法。

方法__init__()是一个特殊的方法,方法的名称开头和末尾各有两个下划线,这是一种约定,旨在避免Python默认方法与普通方法发生冲突。在这个方法的定义中,形参self必不可少,还必须位于其他形参的前面,Python调用方法__init__创建实例时,将自动传入实参self。每个与类相关联的方法调用,都自动传递实参self,它是一个指向实例本身的引用,让实例能够访问类中的属性和方法,self后面的实参可以是字符串、值、列表、元组、字典等。以self为前缀的变量都可供类中的所有方法使用,还可以通过类的任何实例来访问这些变量,如:self.name,像这样可以通过实例访问的变量称为属性(property)

访问实例的属性,可以使用句点表示法,格式:instance_name.property_name,修改属性值的方法:①直接通过实例访问修改;②通过方法修改属性的值;③使用方法对属性值进行计算调整。

根据类创建实例后(可以创建任意数量的实例),可以用句点表示法来调用类中定义的任何方法,格式:instance_name.function_name()

类的PEP8格式:

class class_name:

# 空格一行

def __init__(self, formal_parameters): # 类初始化要缩进\t

self.formal_parameters = formal_paramerters # 初始化内容,建立属性property

# 空格一行

def function_name(self, formal_parameters): # 创建方法

print(self.formal_parameters) # 在方法中通过句点表示法使用属性

方法内容

#空格两行,进入实例创建

instance_name = class_name # 创建实例

instance_name.function_name(actual_parameters) # 通过实例,使用句点表示法使用类中的方法,引入实参

print(instance_name.property_name) #通过实例,调用属性

47.继承:一个类继承另一个类时,它将自动获得另一个类的所有属性和方法,被继承的类称为父类(parent class),也称为超类(superclass),而新类称为子类(child class)。子类继承了其父类的所有属性和方法,同时还可以定义自己的属性和方法,对于一个名称相同的方法,子类将使用自己的方法,忽略父类下的该同名方法。

48.子类的创建格式

#父类必须包含在当前文件中,且位于子类前面

class parent_class_name:

def __init__(self, formal_parameters):

建立属性

#空格一行

def function_name(self, formal_parameters):

方法内容

#空格两行,再建立子类

class child_class_name(parent_class_name):

def __init__(self, formal_parameters):

super().__init__(formal_parameters)

new_parameters # 增加自有的属性

def new_function(formal_parameters): # 增加新的方法

方法内容

# super()是函数,子类继承了父类的属性和方法,同时可以增加自有的属性和方法。

函数super()帮助Python将父类和子类关联起来。

49.将实例用作类的属性:可以将一个类(类1)的实例(实例1)作为另一个类(类2)的属性,实例带有原有类的所有属性和方法,通过句点表示法访问类1中的方法:类2的实例名.类2的属性名.类1中方法的名称,格式:instance_name2.property_name2.function_name1。

50.导入类:Python允许将类存储在模块中,然后主程序中导入所需的模块和模块内预设的类,主程序可以继续按照正常语法创建导入类的实例和调用方法、属性、继承的父类内容等。用逗号隔开,可以从一个模块中导入多个类。

格式:from module_name import class_name_1, class_name_2

instance_name_1.function_name_1(actual_parameters)

instance_name_2.property_name_2

51.导入整个模块,格式:import module_name

再调用模块中的类,格式:module_name.class_name

52.导入模块中的所有类,格式:from module_name import * (由于导入的类不能直观看到,出错率较大,不推荐使用)。

53.类编码风格:类名应采用驼峰命名法,即将类名中的每个单词的首字母都大写,其余小写,而且不使用下划线。实例名和模块名都采用小写格式,并在单词之间加下划线。

对于每个类,都应紧跟在类定义后面包含一个文档字符串,简要地描述类的功能,并遵循编写函数的文档字符串时采用的格式约定。

每个模块也都应该包含一个文档字符串,对其中的类可用于做什么进行描述。

在类中,使用一个空行来分隔方法;在模块中,使用两个空行来分隔类。

需要同时导入标准库中的模块和自己编写的模块时,先编写导入标准库的import语句,再添加一个空行,然后不编写导入自己编写的模块的import语句。

54.Python标准库:是一组模块,所有安装的Python都包含Python标准库。

如使用模块collections中的OrderedDict类,OrderedDict实例行为几乎与字典相同,区别在于记录了键-值对的添加顺序:

from collections import OrderedDict # 导入模块中的类

# 空格一行

favorite_languages = OrderedDict() # 创建实例instance

# 空格一行

favorite_languages['jen'] = 'python'

favorite_languages['sarah'] = 'c'

favorite_languages['edward'] = 'ruby'

favorite_languages['phil'] = 'python'

# 空格一行

for name, language in favorite_languages.items():

print(name.title() + "'s favorite language is " + language.title() + ".")

编译后,输出:

Jen's favorite language is Python.

Sarah's favorite language is C.

Edward's favorite language is Ruby.

Phil's favorite language is Python.

55.文件读取

函数open():接受两个参数,即open(file_path, mode),第一个是要打开的文件的名称或路径,Python会在当前执行的文件所在的目录中查找指定的文件,然后返回一个表示文件的对象,Python将这个对象存储在后面要使用的变量中;第二个是文件的打开模式,包括读取模式(‘r')写入模式('w')附加模式(’a‘)、或者可以同时读取和写入的模式(’r+‘)。打开模式若不填,则默认以只读模式打开文件;写入模式下,若要写入的文件不存在,函数open()会自动创建一个同位置同名的文件,若要写入的文件已存在,Python将在返回文件对象前清空该文件。(注意:Python只能将字符串写入文本文件中,要将数值数据存储到文件文件中,必须先使用函数str()将其转换为字符串格式。)

函数close():接受一个参数,即要关闭的文件的名称,Python会对当前打开的文件执行关闭(当程序有bug时,导致程序未执行到close(),文件将不会关闭,可能进一步导致数据丢失或受损;或者过早地关闭文件,导致无法访问文件)。

关键字with:在不需要访问文件后将其关闭。使用关键词with时,open()返回的文件对象只在with代码块内可用。如果要在with代码块外访问文件的内容,可在with代码块内将文件的各行存储在一个列表中,并在with代码块外使用该列表。

方法read():读取打开的文件的全部内容,可以将读取的内容作为一个字符串存储在一个变量中,方便后续调用。方法read()在读取到文件末尾时返回一个空字符串,而将这个空字符串显示出来时就是一个空行。要删除多出来的空行,可以使用方法rstrip()。(读取文本文件时,Python将其中的所有文本都解读为字符串)。

方法readlines():从文件中读取每一行,并将其存储在一个列表中。

方法replace():将字符串中特定的字符部分都替换为另一个字符部分,格式:string_name.replace(‘original_string', 'new_string'),并且不改变变量在内存中的内容,只是在输出结果上做了替换。

方法split():以空格为分隔符将字符串分拆成多个部分,并将这些部分都存储到一个列表中,结果是一个包含字符串中所有单词的列表,虽然有些单词可能包含标点。

方法count():可以确定特定的单词或短语在字符串中出现了多少次,格式:string_name.count('words')

文件路径:在Windows系统中,文件路径使用反斜杠(\)(注意:也可以使用斜杠,大多数情况下同样可以识别,但是有特殊情况会导致无法读取路径);在Linux和OS X中,文件路径使用斜杠(/)。Python会根据提供的文件路径到系统的特定位置查找文件。相对文件路径:指相对于当前运行的程序所在的目录,如:file_path = 'text_files\filename.txt;绝对文件路径:指文件在计算机中的准确位置,如:file_path = 'C:\\Users\\Lenovo\\documents.txt'。

由于反斜杠(\)在Python中表示转义符,所以如果要用反斜杠表示路径,则必须使用双反斜杠,或者使用原始字符串常量(raw string),即(r),可以让字符保持原来的意思,如:file_path = C:\\Users\\Lenovo\\documents.txt',或者file_path = r'C:\\Users\\Lenovo\\documents.txt'。

56.Python使用异常来管理程序执行期间发生的错误。当发生错误时,如果有编写里对应的异常处理代码,即try-excepttry-except-else(except中异常执行对策可以使用pass语句,告诉Python什么都不要做),程序将继续运行,如果没有,程序将停止,并显示traceback。

常见的异常:FileNotFoundError、ZeroDivisionError、ValueError

格式:

try:

异常程序内容

except 错误类型:

异常执行对策 # 或者使用:pass

else:

无异常,继续执行内容

57. 将数据存储到文件

JSON(JavaScript Object Notation)格式最初是为JavaScript开发的,但随后成了一种常见的格式,被包括Python在内的众多语言采用。

函数json.dump()接受两个实参:要存储的数据以及可用于存储数据的文件对象,可以将数据存储到.json文件中,格式:json.dump(value, file_object)。

函数json.load()接受储存数据的文件对象,将.json文件内容读取到程序中,格式:json.load(file_object)。

58.重构:代码能够正确的运行,但可以做进一步的改进,将代码划分为一系列完成工作的函数。

59.测试代码

单元测试用于核实函数的某个方面没有问题;测试用例是一组单元测试,这些单元测试一起核实函数在各种情形下的行为都符合要求。良好的测试用例考虑到了函数可能收到的各种输入,包含针对所有这些情形的测试。全覆盖式测试用例包含一整套单元测试,涵盖了各种可能的函数使用方式。

运行测试用例时,每完成一个单元测试,Python都打印一个字符:测试通过时打印一个句点;测试引发错误时打印一个E;测试导致断言失败时打印一个F

这就是运行测试用例时,在输出的第一行中看到的句点和字符数量各不相同的原因。如果测试用例包含很多单元测试,需要运行很长时间,就可以通过观察这些结果来获悉有多少个测试通过了。

Python标准库中的模块unittest提供了代码测试工具,要为函数编写测试用例,可先导入模块unittest以及要测试的函数,再创建一个继承unittest.TestCase的类,并编写一系列方法对函数行为的不同方面进行测试。

函数测试格式:

import unittest # 导入unittest

from module_name import function_name # 导入要测试的函数

class child_class_name(unittest.TestCase)

测试内容和断言代码 # 如self.assertEqual(a, b)

unittest.main() # 让Python运行这个文件中的测试

60.unittest.TestCase类中提供了很多断言方法,断言方法用来核实得到的结果是否与期望的结果一致。

unittest Module中的断言方法:

assertEqual(a, b):核实a == b

assertNotEqual(a, b):核实a != b

assertTrue(x):核实x为True

assertFalse(x):核实x为False

assertIn(item, list):核实item在list中

asserNotIn(item, list):核实item不在list中

61.方法setUp():测试自己编写的类时,方法setUp()让测试方法编写起来更容易,可在setUp()方法中创建一系列实例并设置它们的属性,再在测试方法中直接使用这些实例。相比在每个测试方法中都创建实例并设置其属性,要容易得多。

二、模块(Module)

1. pygame库中的函数、方法、属性、事件

函数pygame.image.load('image_address')用于加载游戏中的图片;

方法get_rect()可以获取图片的surface属性rect,可以像处理矩形(rectangle,即rect对象)一样处理游戏图片元素,不用在意图片形状的规则与否。处理rect对象时,可以使用矩形四角和中心的x和y坐标,通过设置这些值来指定矩形的位置,要将游戏元素居中,可设置相应rect对象的属性center、centerx、centery;要让游戏元素与屏幕边缘对齐,可使用属性top、bottom、left或者right;要调整游戏元素的水平或者垂直位置,可使用属性x和y,它们分别是相应矩形左上角的x和y坐标。在Pygame中,原点(0, 0)位于屏幕左上角,向右下方移动时,坐标值将增大。

函数pygame.event.get()用户使用鼠标和按键时,都会在pygame注册一个事件,该函数可以获取该事件;

事件pygame.QUIT获得退出事件;

事件pygame.KEYDOWN获得键盘按下事件;

事件pygame.KEYUP获得键盘放开事件;

事件pygame.K_RIGHT获得键盘方向键右箭头事件;

事件pygame.K_LEFT获得键盘方向键左箭头事件;

事件pygame.K_SPACE获得键盘空格键事件;

函数sys.exit()退出当前程序;

函数screen.fill((R_value, G_value, B_value))给屏幕填充背景颜色;

函数pygame.displa.flip()让最近绘制的屏幕可见;

方法pygame.draw用于在屏幕上绘制对象;

surface属性rect.right表示外接矩形的右边缘的x坐标;

surface属性rect.left表示外接矩形的左边缘的x坐标。

2. matplotlib库中的函数、属性、方法

函数plot(input_value, output_value, linewidth_value)可指定各种实参,输入值x、输出值y、线宽,对数据绘制折线图;

scatter(x_values, y_values, c='color_value', edgecolor='none', s=dot_size_value)可用于绘制散点图;

方法show(),显示绘制的图表;

方法savefig(),保存绘制的图表;

颜色映射(colormap)是一系列颜色,它们从起始颜色渐变到结束颜色。在可视化中,颜色映射用于突出数据的规律。