《Python编程：从入门到实践》语法知识点总结

友情提醒：本文中函数方法表格初学者不必全部记下来，只需要保存图片或者收藏本文，使用时自己方便查询即可。
本文同样有关于Python语法的细节问题，可以用来查漏补缺。
本文更加适合大一刚学习完C语言，想要学习Python的同学。

文章目录

《Python编程：从入门到实践》语法知识点总结
- 第二章：变量和简单的数据类型
- 第三章：列表简介
- 第四章：操作列表
- 第五章：if语句
- 第六章：字典
- 第七章：用户输入和while循环
- 第八章：函数
- 第九章：类
- 第十章：文件和异常
- 第十一章：测试代码
- 另附：

第二章：变量和简单的数据类型

python可以直接使用变量而不用声明
message='hello!' print(message)
- 1
- 2
- 1
- 2

使用方法修改字符串的大小写

name='hello python'
print(name.title())#title()以首字母大写的方式显示每个单词
name='Hello Python'
print(name.upper())#upper()将字符串改为全部大写
print(name.lower())#lower()将字符串改为全部小写

Hello Python HELLO PYTHON hello python

合并（拼接）字符串

first_name='hello'
second_name='python'
full_name=first_name+' '+second_name
print(full_name)
print(first_name+' '+second_name)

hello python hello python

删除空白

name='python '
print(name.rstrip())#rstrip()只是暂时删除字符串末尾的空白
print(name)#输出字符串末尾仍有空格
name=name.rstrip()#将删除操作结果存回到变量中可永久删除空白
print(name)#输出字符串末尾无空格
name=' python '
print(name.lstrip())#删除字符串开头的空白
print(name.strip())#删除字符串两端的空白

**为乘方运算
使用函数str()避免类型错误：将非字符串值表示为字符串
age=23#错误代码 message='happy '+age+'rd birthday' print(message)
- 1
- 2
- 3
- 1
- 2
- 3
```
age=23#正确代码
message='happy '+str(age)+'rd birthday'
print(message)
```
- 1
- 2
- 3
- 1
- 2
- 3

`第三章：列表简介`

列表由一系列按特定顺序排列的元素组成。其中的元素之间可以没有任何关系。在python中用[ ]来表示列表，并用逗号分隔其中的元素
cars=['car1','car2','car3'] print(cars) print(cars[0]) cars[0]='yeah' print(cars[0]) cars.append('car4')#在列表末尾添加元素 print(cars)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
```
['car1','car2','car3']#输出列表，包括方括号
car1#只返回元素
yeah
['yeah','car2','car3','car4']
```
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
方法append()可以轻松地创建动态列表。例如先创建一个空列表，再使用append()添加元素。
使用方法insert()可在列表的任何位置添加新元素。为此需要指定新元素的索引和值。
cars=['car1','car2','car3'] cars.insert(0,car0) print(cars)
- 1
- 2
- 3
- 1
- 2
- 3
```
['car0','car1','car2','car3']#将列表中既有的每个元素向右移一位
```
- 1
- 1
使用del语句删除元素
cars=['car1','car2','car3'] print(cars) del cars[0] print(cars)
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
```
['car1','car2','car3']
['car2','car3']
```
- 1
- 2
- 1
- 2
使用方法pop()删除元素，并能够接着使用它
cars=['car1','car2','car3','car4'] car=cars.pop()#删除末尾元素 car=cars.pop(0)#指定要删除元素的索引删除元素 car='car3' cars.remove(ca0r)#只知道要删除元素的值，而不知道其位置
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
方法remove()只删除第一个指定的值。如果要删除的值再列表中出现多次，就需要循环判断是否删除了所有这样的值。

使用sort()对列表进行永久性排序

sort()#按照字母顺序永久排序
sort(reverse=True)#按照与字母顺序相反的顺序永久排序

使用sorted()对列表进行临时排序
sorted()#按照字母顺序临时排序 sorted(reverse=True)#按照与字母顺序相反的顺序临时排序
- 1
- 2
- 1
- 2
使用方法reverse()永久性反转列表元素的排列顺序
```
cars=['car1','car2','car3','car4']
print(cars)
cars.reverse()
print(cars)
```
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
['car1','car2','car3','car4'] ['car4','car3','car2','car1']
- 1
- 2
- 1
- 2
使用len()确定列表长度

列表索引

cars=['car1','car2','car3','car4']
print(cars[-1])

car4

列表函数方法

第四章：操作列表

遍历整个列表

cars=['car1','car2','car3','car4']
for car in cars:
print(car)

car1 car2 car3 car4

创建数值列表
1. 使用函数range()
```
for value in range(1,5)
print(value)
```
  - 1
  - 2
  - 1
  - 2
  1 2 3 4
  - 1
  - 2
  - 3
  - 4
  - 1
  - 2
  - 3
  - 4
2. 要创建数字列表，可使用函数list()将range()的结果直接转换为列表
```
numbers=list(range(1,6))
print(number)
```
  - 1
  - 2
  - 1
  - 2
  [1,2,3,4,5]
  - 1
  - 1
3. 使用函数range()时还可以指定步长
```
even_numbers=list(range(2,11,2))#打印1~10内的偶数
print(even_numbers)
```
  - 1
  - 2
  - 1
  - 2
对数字列表执行简单的统计计算
numbers=[1,2,3,4,5,6,7,8,9] print(min(numbers)) print(max(numbers)) print(sum(numbers))
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4

列表解析

numbers=[value**2 for value in range(1,11)]#注意for循环无冒号

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

切片

cars=['car1','car2','car3','car4','car5','car6']
print(cars[0:3])
print(cars[:3])#如果没有指定第一个索引，从列表开头开始
print(cars[3:])#如果没有指定第二个索引，到列表末尾终止
print(cars[-3:])
my_cars=cars[:]#复制列表
my_cars=cars#这样复制列表错误！！！

['car1','car2','car3'] ['car1','car2','car3'] ['car4','car5','car6'] ['car4','car5','car6']

元素值不可变的列表称为元组：使用圆括号标识
虽然不能修改元组的元素，但可以给存储元组的变量赋值

第五章：if语句

```
age=20
if age==20 :
print('yeah')
```
- 1
- 2
- 3
- 1
- 2
- 3
使用and（相当于C++中的 && ）和or（相当于C++中的 || ）检查多个条件
要判断特定的值是否已包含在列表中，可使用关键字in
要判断特定的值是否不包含在列表中，可使用关键字not in
布尔表达式的值要么为True，要么为False
hello=Ture hello=False
- 1
- 2
- 1
- 2
if - elif- else结构
判断语句中列表为空时返回False

第六章：字典

字典用放在花括号{}中的一系列键值对表示

cars={'car1':'green'}
print(cars[car1])
cars['car2']='red'
print(cars)
cars['car2']='black'
print(cars[car2])
del cars['car2']
print(cars)

green {'car1':'green','car2':'red'} black {'car1':'green'}

cars={'car1':'green','car2':'red'}
for key,value in cars.items():#遍历所有的键值对
print(key+' '+value)
for key in cars.keys():#提取键到key中
print(key)
for key in cars:#等价于for key in cars.keys():
print(key)
for value in cars.values():
print(value)

方法items()返回一个键值对列表

方法keys()并非只能用于遍历，实际上，它返回一个列表，其中包含字典中的所有键

方法value()返回一个值列表

要以特定的顺序返回元素，一种办法是在for循环中对返回的键进行排序。为此，可使用函数sorted()来获得按特定顺序排序的键列表的副本
集合（set）类似于列表，但每一个元素都是独一无二的
cars={'car1':'green','car2':'red'，'car3':'red'} for car in set(cars.values()) print(car)
- 1
- 2
- 3
- 1
- 2
- 3
```
green
red
```
- 1
- 2
- 1
- 2
字典中可以嵌套列表，列表中也可以嵌套字典，字典中也可以嵌套字典
字典函数方法

`第七章：用户输入和while循环`

input()函数：将用户输入解读为字符串
message=input('Tell me something:') #先打印Tell me something:，然后将输入存储在变量message中 enquiry=Tell me something message=input(enquiry)
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
函数int()将数字的字符串转换为数值表示

让用户选择何时退出

message=''#将变量message初始值设置为空字符串
while message!='quit':
message=input()
print(message)

使用标志
active=True while active: message=input() if message == 'quit': active=False else: print(message)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
使用break退出循环，在循环中使用continue
Ctrl+C退出无限循环
在for循环中不应修改列表，否则将导致难以跟踪其中元素
enumerate()函数讲解
要在遍历列表的同时对其进行修改，可使用while循环

第八章：函数

定义函数
```
def greet_user():
print('Hello')
```
- 1
- 2
- 1
- 2
关键字实参
def describe_pet(animal_type,pet_name): print(animal_type+pet_name) describe_pet(animal_type='dog',pet_name='wct')#与下面一行函数调用等效 describe_pet(pet_name='wct',animal_type='dog')
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
编写函数时，可给每个形参指定默认值
```
def describe_pet(animal_type,pet_name='wct'):
print(animal_type+pet_name)
describe_pet(animal_type='dog')#与下面一行函数调用等效
describe_pet('dog')
```
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
使用默认值时，在形参列表中必须先列出没有默认值的形参，在列出有默认值的实参
返回使用return。函数可以返回任何类型的值，包括列表和字典等
def name(first_name,last_name): person={'first':full_name,'last':last_name} return person
- 1
- 2
- 3
- 1
- 2
- 3
让实参变成可选的
```
def name(first_name,middle_name,last_name):
full_name=first_name+' '+middle_name+' 'last_name
return full_name
```
- 1
- 2
- 3
- 1
- 2
- 3
为了让name()在没有提供中间名时仍然可行，可给实参middle_name指定一个默认值——空字符串，并将其移动到形参列表的末尾：
def name(first_name,last_name,middle_name=''): full_name=first_name+' '+middle_name+' 'last_name return full_name
- 1
- 2
- 3
- 1
- 2
- 3
禁止函数修改列表
```
function_name(list_name[:])
```
- 1
- 1
切片表示法[:]创建列表的副本
传递任意数量的实参
def make_pizza(*toppings): print(toppings) make_pizza('a','b','c')
- 1
- 2
- 3
- 1
- 2
- 3
```
('a','b','c')
```
- 1
- 1
形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。
结合使用位置实参和任意数量形参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。

Python先匹配位置实参和关键字实参，再将剩下的实参都收集到最后一个形参中。
def make_pizza(size,*toppings)
- 1
- 1

使用任意数量的关键字实参

def build_profile(first,last,**user_info):
profile={}
profile['first_name']=first
profile['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)

1
2
3
4
5
6
7
8
9
10
11

1
2
3
4
5
6
7
8
9
10
11

形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称值对都封装到这个字典中。

import语句允许在当前运行的程序文件中使用模块中的代码。模块是拓展名为.py的文件。
import moudle_name#导入整个模块 moudle_name.function_name() from moudle_name import function_name#导入模块中的特定函数 from moudle_name import function_0,function_1#导入模块中任意数量的函数 function_name()#若使用这种语法，调用函数时就无需使用句点
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6

使用as给函数指定别名

fron moudle_name import function_name as fn

使用as给模块指定别名
import mouble_name as mn
- 1
- 1
导入模块中所有函数
```
from moudle_name import *
```
- 1
- 1
这样导入无需使用句点表示法，但使用并非自己编写的大型模块时，最好不要采用这种导入方法

要么只导入自己需要的函数，要么导入整个模块并使用句点表示法
给形参指定默认值时等号两边不要有空格

对于函数调用中的关键字实参，也应遵循这种约定
如果形参很多，导致函数定义的长度超过了79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来。
def function_name( parameter_0,parameter_1,parameter_2, parameter_3,parameter_4,parameter_5): function body...
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
所有的import语句都应放在文件开头

第九章：类

使用类和实例

class Dog():#首字母大写的名称指的是类
def__init__(self,name,age):
self.name = name
self.age = age
self.color = 'black'#给属性指定默认值

def sit(self):
print(self.name.title() + ' is now sitting.')

def roll_over(self)
print(self.name.title() + ' rolled over!')

    def change_age(self,changed_age)
    self.age=changed_age

my_dog = Dog('wct',20)
print(my_dog.name+' '+str(my_dog.age))
my_dog.sit()
my_dog.roll_over()
my_dog.age = 21#直接修改属性的值
my_dog.change_age(21)#通过方法修改属性的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def__init__(self,name,age): self.name = name self.age = age

以self为前缀的变量都可供类中的所有方法使用。可通过实例访问的变量成为属性。

继承
重写父类

将实例用作属性

class Car():

class Battery():
def __init__(self,battery_size=70):
self.battery_size = battery_size
def describe_battery(self):
print(str(self.battery_size))

class ElectricCar(Car):
def __init__(self,make,model,year):
super().__init__(make,model,year)
self.battery = Battery()

my_car = ElectricCar('tesla','model s',2016)
my_car.battery.describe_battery()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

可以创建一个 .py 文件储存类
fron module_name class_name1,class_name2#car.py import module_namer#导入整个模块，再使用句点表示法访问需要的类 from module_name import * #导入模块中的所有类
- 1
- 2
- 3
- 1
- 2
- 3
类编码风格

第十章：文件和异常

读取整个文件
```
with open('pi.txt') as file_object:#pi.txt在源码所在目录中
contents = file_object.read()
print(contents)
```
- 1
- 2
- 3
- 1
- 2
- 3
函数open()接受一个参数：文件的名称

关键字with在不需要访问文件后将其关闭

方法read()读取文件的全部内容
文件路径
with open('text_files\filename.txt') as file_object:#相对路径 file_path = 'C:\User\ehmatthes\other_files\text_files\filename.txt' with open(file_path) as file_object: #绝对路径通常比相对路径更长，因此将其存储在一个变量中，再将该变量传递给open()
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5

逐行读取

filename = 'pi.txt'

with open(filename) as file_object:
for line in file_object:
print(line.rstrip)#如果没有rstrip每一行后会有一条空白行

创建一个包含文件各行内容的列表

使用关键字with时，open()返回的文件对象只能在with代码块内使用

如果要在with代码块外访问文件的内容，可在with代码块内将文件的各行存储在一个列表中
filename = 'pi.txt' with open(filename) as file_object: lines = file_object.readlines()#方法readlines()从文件中读取每一行并将其存储在一个列表中 pi_string = '' for line in lines: pi_string += line.strip()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
写入空文件
写入多行

函数write()不会在写入的文本末尾添加换行符

附加到文件

with open(filename,'a') as file_object:

异常是使用try-except代码块处理的。使用try-except代码块，即便出现异常，程序也将继续运行
first_number = input() second_number = input() try: ans = int(first_number) / int(second_number) except ZeroError: print('error!') else print(ans)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8

分析文本

title = 'a b c'
title.split()#方法split()以空格为分隔符讲字符串拆成多个部分，并储存在一个列表中

['a','b','c']

pass语句：可在代码块中使用它让Python什么也不做
```
first_number = input()
second_number = input()
try:
ans = int(first_number) / int(second_number)
except ZeroError:
pass
else
print(ans)
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
pass语句还充当了占位符，它提醒你在程序的某个地方什么也没做，并且以后也需要在这里做些什么。例如，我们可能决定讲找不到的文件的名称写入到文件messing.txt中。用户看不见这个文件，但我们可以读取这个文件，进而处理所有文件找不到的问题。
存储数据：模块json让你能够讲简单的Python数据结构储存到文件中，并在程序再次运行时加载该文件中的数据。
使用json.dump()和json.load()

函数json.dump()接受两个实参：要存储的数据一级可用于存储数据的文件对象
import json numbers = [2,3,5,7,11,13] filename = 'numbers.json'#文件拓展名.json with open(filename,'w') as f_boj: json.dump(numbers,f_obj)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
```
import json

filename = 'numbers.json'#读取文件
with open(filename) as f_boj:
numbers = json.load(f_obj)
```
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
import json filename = 'username.json' try: with open(filename) as f_obj: username = json.load(f_obj) except FilenameFoundError: username = input(what is your name?) with open(filename,'w') as f_obj: json.dump(username,f_obj) print('we will remember you when you come back!') else print('welcome back')
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
重构：代码可以正确运行，但可以做进一步的改进——将代码划分为一系列完成具体工作的函数，这样的过程被称为重构。

第十一章：测试代码

Python标准库中的模块unittest提供了代码测试工具

编写测试用例，可先导入模块unittest以及要测试的函数，再创建一个继承unittest.TestCase的类，并编写一系列方法对函数行为的不同方面进行测试。

import unittest
from nume_function import get_formatted_name

class NamesTestCase(unittest.TestCase):#必须继承unittest.TestCase类
def test_name(self):#运行此文件时，所有以test_打头的方法都将自动运行
formatted_name = get_formatted_name('a','b')
self.assertEqual(formatted_name,'a b')

unittest.main()