《Python编程：从入门到实践》语法知识点总结 这一篇就够了

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

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

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

1. python可以直接使用变量而不用声明

   message="hello!"
   print(message)

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

3. 合并（拼接）字符串

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

   hello python
   hello python

4. 删除空白

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

5. **为乘方运算

6. 使用函数str()避免类型错误：将非字符串值表示为字符串

   age=23					#错误代码
   message="happy "+age+"rd birthday"
   print(message)

   age=23					#正确代码
   message="happy "+str(age)+"rd birthday"
   print(message)

第三章：列表简介

1. 列表由一系列按特定顺序排列的元素组成。其中的元素之间可以没有任何关系。在python中用[ ]来表示列表，并用逗号分隔其中的元素

   cars=["car1","car2","car3"]
   print(cars)
   print(cars[0])
   cars[0]="yeah"
   print(cars[0])
   cars.append("car4")			#在列表末尾添加元素
   print(cars)

   ["car1","car2","car3"]		#输出列表，包括方括号
   car1						#只返回元素
   yeah
   ["yeah","car2","car3","car4"]

   方法append()可以轻松地创建动态列表。例如先创建一个空列表，再使用append()添加元素。

2. 使用方法insert()可在列表的任何位置添加新元素。为此需要指定新元素的索引和值。

   cars=["car1","car2","car3"]
   cars.insert(0,car0)
   print(cars)

   ["car0","car1","car2","car3"]		#将列表中既有的每个元素向右移一位

3. 使用del语句删除元素

   cars=["car1","car2","car3"]
   print(cars)
   del cars[0]
   print(cars)

   ["car1","car2","car3"]
   ["car2","car3"]

4. 使用方法pop()删除元素，并能够接着使用它

   cars=["car1","car2","car3","car4"]
   car=cars.pop()		#删除末尾元素
   car=cars.pop(0)		#指定要删除元素的索引删除元素
   car="car3"
   cars.remove(ca0r)	#只知道要删除元素的值，而不知道其位置

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

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

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

6. 使用sorted()对列表进行临时排序

   sorted()					#按照字母顺序临时排序
   sorted(reverse=True)		#按照与字母顺序相反的顺序临时排序

7. 使用方法reverse()永久性反转列表元素的排列顺序

   cars=["car1","car2","car3","car4"]
   print(cars)
   cars.reverse()
   print(cars)

   ["car1","car2","car3","car4"]
   ["car4","car3","car2","car1"]

8. 使用len()确定列表长度

9. 列表索引

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

   car4

10. 列表函数方法

第四章：操作列表

1. 遍历整个列表

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

   car1
   car2
   car3
   car4

2. 创建数值列表

   1. 使用函数range()

      for value in range(1,5)
      	print(value)

      1
      2
      3
      4

   2. 要创建数字列表，可使用函数list()将range()的结果直接转换为列表

      numbers=list(range(1,6))
      print(number)

      [1,2,3,4,5]

   3. 使用函数range()时还可以指定步长

      even_numbers=list(range(2,11,2))	#打印1~10内的偶数
      print(even_numbers)

3. 对数字列表执行简单的统计计算

   numbers=[1,2,3,4,5,6,7,8,9]
   print(min(numbers))
   print(max(numbers))
   print(sum(numbers))

4. 列表解析

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

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

5. 切片
   

   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"]

6. 元素值不可变的列表称为元组：使用圆括号标识
   

7. 虽然不能修改元组的元素，但可以给存储元组的变量赋值

第五章：if语句

1. age=20
   if age==20 :
   	print("yeah")

2. 使用and（相当于C++中的 && ）和or（相当于C++中的 || ）检查多个条件
   

3. 要判断特定的值是否已包含在列表中，可使用关键字in

4. 要判断特定的值是否不包含在列表中，可使用关键字not in
   

5. 布尔表达式的值要么为True，要么为False

   hello=Ture
   hello=False

6. if - elif- else结构

7. 判断语句中列表为空时返回False

第六章：字典

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

2. 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"}

3. 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()返回一个值列表

4. 要以特定的顺序返回元素，一种办法是在for循环中对返回的键进行排序。为此，可使用函数sorted()来获得按特定顺序排序的键列表的副本

5. 集合（set）类似于列表，但每一个元素都是独一无二的

   cars={"car1":"green","car2":"red"，"car3":"red"}
   for car in set(cars.values())
   	print(car)

   green
   red

6. 字典中可以嵌套列表，列表中也可以嵌套字典，字典中也可以嵌套字典

7. 字典函数方法

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

1. input()函数：将用户输入解读为字符串

   message=input("Tell me something:")		
   #先打印Tell me something:，然后将输入存储在变量message中
   enquiry=Tell me something
   message=input(enquiry)

2. 函数int()将数字的字符串转换为数值表示

3. 让用户选择何时退出

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

4. 使用标志

   active=True
   while active:
   	message=input()
   	if message == "quit":
   		active=False
   	else:
   		print(message)

5. 使用break退出循环，在循环中使用continue

6. Ctrl+C退出无限循环

7. 在for循环中不应修改列表，否则将导致难以跟踪其中元素
   enumerate()函数讲解

8. 要在遍历列表的同时对其进行修改，可使用while循环

第八章：函数

1. 定义函数

   def greet_user():
   	print("Hello")

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")

3. 编写函数时，可给每个形参指定默认值

   def describe_pet(animal_type,pet_name="wct"):
   	print(animal_type+pet_name)
   describe_pet(animal_type="dog")					#与下面一行函数调用等效
   describe_pet("dog")

   使用默认值时，在形参列表中必须先列出没有默认值的形参，在列出有默认值的实参

4. 返回使用return。函数可以返回任何类型的值，包括列表和字典等

   def name(first_name,last_name):
   	person={"first":full_name,"last":last_name}
   	return person

5. 让实参变成可选的

   def name(first_name,middle_name,last_name):
   	full_name=first_name+" "+middle_name+" "last_name
   	return full_name

   为了让name()在没有提供中间名时仍然可行，可给实参middle_name指定一个默认值——空字符串，并将其移动到形参列表的末尾：

   def name(first_name,last_name,middle_name=""):
   	full_name=first_name+" "+middle_name+" "last_name
   	return full_name

6. 禁止函数修改列表

   function_name(list_name[:])

   切片表示法[:]创建列表的副本

7. 传递任意数量的实参

   def make_pizza(*toppings):
   	print(toppings)
   make_pizza("a","b","c")

   ("a","b","c")

   形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。

8. 结合使用位置实参和任意数量形参

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

   Python先匹配位置实参和关键字实参，再将剩下的实参都收集到最后一个形参中。

   def make_pizza(size,*toppings)

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

   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)

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

10. 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()						#若使用这种语法，调用函数时就无需使用句点

11. 使用as给函数指定别名

    fron moudle_name import function_name as fn

12. 使用as给模块指定别名

    import mouble_name as mn

13. 导入模块中所有函数

    from moudle_name import *

    这样导入无需使用句点表示法，但使用并非自己编写的大型模块时，最好不要采用这种导入方法

    要么只导入自己需要的函数，要么导入整个模块并使用句点表示法

14. 给形参指定默认值时等号两边不要有空格

    对于函数调用中的关键字实参，也应遵循这种约定

15. 如果形参很多，导致函数定义的长度超过了79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来。

    def function_name(
    		parameter_0,parameter_1,parameter_2,
    		parameter_3,parameter_4,parameter_5):
    	function body...

16. 所有的import语句都应放在文件开头

第九章：类

1. 使用类和实例

   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)	#通过方法修改属性的值

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

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

2. 继承

   

3. 重写父类
   

4. 将实例用作属性

   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()

5. 可以创建一个 .py 文件储存类

   fron module_name class_name1,class_name2		#car.py
   import module_namer				#导入整个模块，再使用句点表示法访问需要的类
   from module_name import * 		#导入模块中的所有类

6. 类编码风格

   

第十章：文件和异常

1. 读取整个文件

   with open('pi.txt') as file_object:		#pi.txt在源码所在目录中
   	contents = file_object.read()
   	print(contents)

   函数open()接受一个参数：文件的名称

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

   方法read()读取文件的全部内容

2. 文件路径

   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()

3. 逐行读取

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

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

   使用关键字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()

5. 写入空文件

   

6. 写入多行

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

7. 附加到文件

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

8. 异常是使用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)

9. 分析文本

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

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

10. pass语句：可在代码块中使用它让Python什么也不做

    first_number = input()
    second_number = input()
    try:
    	ans = int(first_number) / int(second_number)
    except ZeroError:
    	pass
    else
    	print(ans)

    pass语句还充当了占位符，它提醒你在程序的某个地方什么也没做，并且以后也需要在这里做些什么。例如，我们可能决定讲找不到的文件的名称写入到文件messing.txt中。用户看不见这个文件，但我们可以读取这个文件，进而处理所有文件找不到的问题。

11. 存储数据：模块json让你能够讲简单的Python数据结构储存到文件中，并在程序再次运行时加载该文件中的数据。

12. 使用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)

    import json
    
    filename = 'numbers.json'				#读取文件
    with open(filename) as f_boj:	
    	numbers = json.load(f_obj)

    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")

13. 重构：代码可以正确运行，但可以做进一步的改进——将代码划分为一系列完成具体工作的函数，这样的过程被称为重构。

第十一章：测试代码

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

2. 编写测试用例，可先导入模块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()

   方法名必须以test_打头，这样它才可以自动运行

3. 各种断言方法
   

4. 方法setUp()
   unittest.TestCase类中包含了方法setUp()，Python将先运行它，再运行各个以TEST_打头的方法。
   

5. 在项目早期，不要试图去编写全覆盖的测试用例，除非有充分的理由这样做。

另附：

注意，光看理论还是不行的，实战才是核心。最后送大家一套2020最新企业Python项目实战视频教程，点进这里进来获取，跟着练习下，希望大家一起进步哦！

总结《Python编程：从入门到实践》且码字制图确实不易.16369字，没有一个字是复制粘贴的。如果本文对你有帮助，请点赞支持。
您的每一次浏览、点赞、收藏和关注对于作者都很重要！感谢！
欢迎添加作者公众号：追猪青年（目前正在建设中）回复：Python学习资源包 获取全部资源