【Python语法】一篇文章带你快速入门Python

✍个人博客：https://blog.youkuaiyun.com/Newin2020?spm=1011.2415.3001.5343
📣专栏定位：为 0 基础 python 或者想要快速复习这门语言的小伙伴整理 python重点语法，帮助大家快速掌握其中重点内容~
📚专栏简介：在这个专栏， 我将整理赫赫有名的 python 必看的蟒蛇书中的内容，会将其中重点内容展示给大家。
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

第1章 变量和简单数据类型

1. 变量名不能包含空格，但能使用下划线来分割其中的单词。

2. 错误情况 NameError : name ‘mesage’ is not defined

   类似这种变量为定义的一般分两种情况：①使用变量前忘给它赋值 ②输入变量名时拼写不正确

3. 改变字符串的大小

   name=‘Jack tom’

   函数	结果
   name.upper( )	JACK TOM
   name.lower()	jack tom
   name.title()	Jack Tom

   这些函数并不会修改初始值

4. 在字符串中使用变量

   f字符串用法：

   【例如】
   first_name='ada'
   last_name='lovelace'
   full_name=f"{first_name} {last_name}"
   print(full_name)
   【输出】
   ada lovelace
   

5. 删除空白

   函数	功能
   name.lstrip()	去开头空白
   name.rstrip()	去尾部空白
   name.strip()	去开头和尾部空白

6. 任意两个数相除时，结果总是浮点数；无论是哪种运算，只要有操作数是浮点数，得到的结果就是浮点数

7. 数字分组

   数字中的下划线可以方便阅读，且不影响结果

   【例如】
   age=14_000_000_000
   print(age)
   【输出】
   14000000000
   

8. 通常使用全大写来指出应将某个变量视为常量

9. 注释用 井号（#） 标识

第2章 列表简介

1. 用方括号[ ]来表示列表

   bicycles = ['trek','cannondale','redline','specialized']
   

2. 索引从0开始而不是1开始，通过将索引指定为-1.可以得到列表最后一个元素

3. 修改、添加和删除列表元素

   （1）修改列表元素

   【输入】
   motorcycles = ['honda','yamaha','suzuki']
   motorcycles[0] = 'ducati'
   print(motorcycles)
   【输出】
   ['ducati','yamaha','suzuki']
   

   （2）在列表中添加元素

   调用函数	操作方式	示例
   list.append(元素)	在末尾处添加	name.append(‘fish’)
   list.insert(索引 , 元素)	在任意位置添加	names.insert(0 , ‘fish’)
   列表相加“+”	合并其他函数	names + names
   列表扩充list.extend(list)	合并其他函数	names.extend(names)

   （3）从列表中删除元素

   调用函数	操作方式	示例
   del 语句	删除某个索引的元素	del names[0]
   del 语句	删除整个列表	del names
   pop( ) 方法	弹出末尾元素	names.pop()
   pop( ) 方法	弹出某索引元素	names.pop(0)
   remove( ) 方法	删除某个值的元素	names.remove(‘dog’)
   clear( ) 方法	清空列表中的元素	names.clear()

   ① 使用pop( )可以弹出一个元素，一旦使用pop( )之后，被弹出的元素就不在列表中了

   ② 方法remove( )只删除第一个指定的值，如果要删除的值可能在列表中出现多次，就需要使用循环

4. 组织列表

   调用函数	操作方式	示例
   sort( ) 方法	使列表元素按照字母顺序排序	cars.sort( ) print(cars)
   sorted( ) 方法	对列表进行临时排序，也是按字母顺序，但不会永久性改变	print(cars) print(sorted(cars)) print(cars)
   reverse( ) 方法	反转列表元素的排序顺序	cars.reverse()

   sorted( )和sort( )的区别

   名称	类型	写法	执行结果	愿列表是否变化
   sort()	列表的方法	xxx.sort()	None	变化
   sorted()	内置函数	sorted(xxx)	新列表	不变

5. 确定列表的长度

   使用 len( ) 可以快速获悉列表的长度

   【输入】
   cars = ['bmw','audi','toyota','subaru']
   len(cars)
   【输出】
   ['ducati','yamaha','suzuki']
   

第3章 操作列表

1. for循环

   【输入】
   magicians = ['alice','david','carolina']
   for magician in magicians:
   print(magician)
   【输出】
   alice
   david
   carolina
   

2. range函数

   ① 正常使用

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

   会得到1,2,3,4但没有5，右边数值不会包含进去

   调用函数range( )时，也可以只指定一个参数，这样它将从0开始。例如，range(6)返回数0~5

   ② 指定步长

   【输入】
   n = list(range(2,11,2))
   print(n)
   【输出】
   [2,4,6,8,10]
   

   上面可以通过list( )将range( )的结果直接转换为列表

   range( )的第一个值代表起始值，第二个值代表终值，第三个值代表步长

   ③ 列表解析

   【输入】
   squares = [value**2 for value in range(1,11)]
   print(squares)
   【输出】
   [1,4,9,16,25,36,49,64,81,100]
   

3. 对列表的简单计算

   函数	功能
   min(list)	取列表的最小值
   max(list)	取列表的最大值
   sum(list)	取列表中所有元素的和

4. 切片

   ① 创建切片

   players[0:3]
   

   players是一个列表，上述会得到此列表的前三个元素

   ② 遍历切片

   for player in players[:3]:
   print(player)
   

   players是一个列表，上述也会得到此列表的前三个元素

   ③ 复制列表

   【代码一】
   my_foods = ['pizza','falafel','carrot cake']
   friend_foods = my_foods[:]
   【代码二】
   my_foods = ['pizza','falafel','carrot cake']
   friend_foods = my_foods
   

   上述两个代码不一样，代码一是将my_foods复制给了friend_foods成为两个列表；而代码二则是将friend_foods与my_foods划等号即实质上两个变量还是用的同一个列表，一方的删减会同步影响到另一方

5. 元组

   ① 定义元组

   dimensions = (200,50)
   

   元组的值和列表不一样，其值是不可以改变的，定义元组只需将定义列表的 [ ] 改为 ( ) 即可

   元组的访问时的语法与列表相同

   如果定义的元组只包含一个元素，则需要在后面加上逗号

   my_t = (3,)
   

   ② 修改元组变量

   修改变量不能通过修改列表元素那样去修改，需要重新定义

   dimensions=(200,50)
   print(dimensions)
   dimensions=(400,100)
   print(dimensions)
   【输出】
   (200,50)
   (400,100)
   

第4章 if语句

1. 要判断特定的值是否已包含在列表中，可使用关键字 in ，当然也可以使用关键字 not in 来确定的值未包含在列表中

2. 如果情况超过两个情形，可使用 if-elif-else 结构，其中else可省略

3. 确定列表不是空的

   requested_toppings = []
   if requested_toppings:
   print('OK')
   else:
   print('Are you sure you want a plain pizza?')
   

第5章 字典

1. 创建并访问字典

   【输入】
   alien_0 = {'color':'green','points': 5}
   print(alien_0['color'])
   【输出】
   green
   

   键值对中，前面为键，后面为值

2. 添加、修改和删除键值对

   【输入】
   alien_0 = {'color':'green','points': 5}
   #添加键值对
   alien_0['x_position'] = 0
   alien_0['y_position'] = 25
   #修改键值对
   alien_0['color'] = 'yellow'
   #删除键值对
   del alien_0['points']
   print(alien_0)
   【输出】
   {'color':'yellow','x_position': 0,'y_position': 25}
   

3. 使用get( )来访问值

   方法get( )的第一个参数用于指定键，是必不可少的；第二个参数为指定的键不存在时要返回的值，是可选的

   【输入】
   alien_0 = {'color':'green'}
   print(alien_0.get('points','No point value assigned.'))
   【输出】
   No point value assigned.
   

4. 遍历字典

   ① 遍历所有键值对

   for k,v in user.items():
       print(k)
       print(v)
   

   其中k对应的是键，而v对应的是值

   ② 遍历所有的键

   代码一
   for name in favorite.keys():
   代码二
   for name in favorite:
   

   代码一和代码二表示的意思相同，name都代表字典中的键，只是代码一表达更清楚一些

   此外，可以通过 sorted( ) 来获得特定顺序排列的键列表的副本

   for name in sorted(favorite.keys( )):
   

   ③ 遍历所有的值

   for language in favorite.values():
   

   language代表字典中的值

   此外，通过对包含重复元素的列表调用set( )，可让Python找出列表中独一无二的元素

   for language in set(favorite.values()):
   【原输出】
   Python
   C
   Python
   【新输出】
   Python
   C
   

   注意：可以使用一对花括号直接创建集合，并在其中用逗号分隔元素,并且集合不会以特定的顺序存储元素

   【输入】
   languages = {'python','ruby','python','c'}
   print(languages)
   【输出】
   {'ruby','python','c}
   

5. 嵌套

   ① 在列表中存储字典

   aliens = []
   for alien_number in range(30):
       new_alien ={'color':'green','points': 5}
       aliens.append(new_alien)
   

   ② 在字典中存储列表

   pizza = {
       'crust':'thick',
       'toppings':['mushrooms','extra cheese'],
   }
   

   ③ 在字典中存储字典

   users = {
       'aeinstein':{
           'first':'albert',
           'last':'einstein',
           'location':'princeton',
       },
       'mcurie':{
           'first':'marie',
           'last':'curie',
           'location':'paris',
       },
   }
   

第6章 用户输入和while循环

1. 函数input( ) 的工作原理

   message = input('Tell me something,and i will repeat it back to you:')
   print(message)
   

   用input( )获得的值是由字符串表示，如果想将输入转化为数值的话要用到int( )函数

   height = int(height)
   

2. 求模运算符 （%）

   >>> 4 % 3
   1
   >>> 5 % 3
   2
   

3. 使用break退出循环

   要立即退出循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用break语句

4. 在循环中使用continue

   使用后会返回循环开头，并跳过continue之后的代码

第7章 函数

1. 定义函数

   【输入】
   def greet_user(username):
   print(f"Hello,{username.title()}!")
   greet_user('jesse')
   【输出】
   Hello,Jesse!
   

   其中username是一个形参，'jesse’是一个实参

2. 传递实参

   【代码一】
   def describe_pet(animal_type,pet_name):
   【代码二】
   def describe_pet(pet_name,animal_type='dog')
   

   代码一为正常的函数定义，代码二则给形参使用了默认值

   但是要注意的是，如果使用默认值且调用时只有一个实参时，默认值顺序需往后放

   【代码三】
   describe_pet('hamster','harry')
   【代码四】
   describe_prt(animal_type='hamster',pet_name='harry')
   

   代码三的实参是位置实参，代码四的实参是关键字实参（不用按照参数顺序来）

3. 返回值

   def name(first_name,last_name):
   full_name = f"{first_name} {last_name}"
   return full_name.title()
   musician = name('jimi','hendrix')
   print(musician)
   

4. 传递任意数量的实参

   【代码一】
   def make_pizza(*toppings):
   print(toppings)
   make_pizza('mushrooms','green peppers','extra cheese')
   >>> ('mushrooms','green peppers','extra cheese')
   

   形参名*toppings中的星号（*）是创建了一个名为toppings的空元组，并将收到的所有值都分装到这个元组中

   经常会看到通用形参名*args，它也收集任意数量的位置形参

   【代码二】
   def build_profile(first,last,**user_info):
   user_info['first_name'] = first
   user_info['last_name'] = last
   return user_info
   user_profile = build_profile('albert','einstein',
   location='princeton',
   field='physics')
   print(user_profile)
   >>> {'location':'princeton','field':'physics',
   'first_name':'albert','last_name':'einstein'}
   

   形参**user_info中的两个星号（**）创建了一个名为user_info的空字典，并将收到的所有名称值对都放到这个字典中；其中（location='princeton'，field='physics'）表示关键字实参

   *经常会看到形参名*kwargs，它用于收集任意数量的关键字实参

5. 将函数存储在模块中

   ① 导入整个模块

   加入已经有写好的程序pizza.py，那么可以通过import来调动这个程序：

   import pizza
   

   当完成上面的步骤即读取程序成功后，调用其中的函数需按以下语法：

   >>> module_name.function_name( )
   

   ② 导入特定函数

   可以导入模块中的特定函数：

   >>> from module_name import function_name
   >>> from module_name import function_0,function_1,function_2
   

   导入后想调用这些函数就不用加上前面的模块名了

   >>> make_pizza(16,'mushrooms')
   

   ③ 导入模块中的所有函数

   >>> from module_name import *
   from pizza import *
   make_pizza(16,'pepperoni')
   

   这个星号就是将模块pizza中的所有函数都复制到这个程序文件中

   这种方法使用需谨慎，如果模块中有函数的名称与当前项目中使用的名称相同，Python会覆盖函数，而不是分别导入所有函数

6. 使用as

   ① 给函数指定别名

   from pizza import make_pizza as mp
   mp(16,'pepperoni')
   

   ② 给模块指定别名

   import pizza as p
   p.make_pizza(16,'pepperoni')
   

第8章 类

1. 创建类

   class Dog:
       def __inti__(self,name,age):
           self.name = name
           self.age = age
           self.fur_colour = white   #默认值
       def sit(self):
           print(f"{self.name} is now sitting.")
       def roll_over(self):
           print(f"{self.name} rolled over!")
       def paw_colour(self,colour):
           self.paw_colour = colour
   dog = Dog(jess,4)
   dog.fur_colour = brown   #直接修改属性
   dog.paw_colour(black)   #通过方法修改属性的值
   

   首字母大写的名称指的是类

   在方法__init__( )中，形参self必不可少，而且必须位于其它形参前面；上面的name和age我们可以仅仅当做两个没有名字的值，然后我们需要创建一个变量即self.name和self.age去把它们装进去

2. 使用类

   class Dog:
       --snip--
   my_dog = Dog('Willie',6)
   #调用属性
   print(f"My dog's name is {my_dog.name}.")
   print(f"My dog is {my_dog.age} years old.")
   #调用方法
   my_dog.sit()
   my_dog.roll_over()
   

3. 继承

   class Car:
       --snip--
       class Battery:
       def __init__(self,battery_size=75):
           self.battery_size = battery_size
       def describe_battery(self):
           print(f"This car has a {self.battery_size}-kWh battery.")
   class ElectricCar(Car):   #ElectricCar这个类继承了Car类的所有内容
       def __init__(self,make,model,year):
           super().__init__(make,model,year)   #super()函数可以调用父类的方法
           self.battery = Battery()
   my_tesla = ElectricCar('tesla','model s','2019)
   my_tesla.battery.describe_battery()   #在类ElectricCar中调用了另一个类Bttery的方法
   

4. 导入类

   ① 导入单个类

   已知文件car.py，从此文件中向另一个文件导入Car类：

   from car import Car
   

   ② 从一个模块中导入多个类

   from car import Car,ElectricCar
   

   ③ 导入整个模块

   import car
   

   ④ 导入模块中的所有类

   >>> from module_name import *
   

   ⑤使用别名

   from electric_car import ElectricCar as EC
   my_tesla = EC('tesla','roadster','2009)
   

5. Python标准库

   ① 函数randint()

   >>> from random import randint
   >>> randint(1,6)
   3
   

   函数会生成一个位于1和6之间的随机整数

   ② 函数choice()

   >>> from random import choice
   >>> players = ['chaeles','martina','michael','florence','eli']
   >>> first_up = choice(players)
   >>> first_up
   'florence'
   

   函数会随即返回其中的一个元素

第9章 文件和异常

1. 从文件中读取数据

   （1）读取整个文件

   [文件pi_digits.txt]
   3.1415926535
    8979323856
    2643383279
   下面程序打开并读取这个文件：
   >>> with open('pi_digits.txt) as file_object:
   >>>     contents = file_object.read()
   >>> print(contents.rstrip())   #rstrip()用于消除原始结果后会空出的一行
   3.1415926535
    8979323856
    2643383279
   

   （2）文件路径

   ① 相对路径

   由于文件夹text_files位于文件夹python_work中，可以使用相对文件路径来打开其中的文件

   with open('text_files/filename.txt') as file_object:
   

   这行代码让Python到文件夹python_work下的文件夹text.files中去查找指定的 .txt文件

   注意：显示文件路径时，代码中可以使用斜杠（/）

   ② 绝对路径

   如果文件不在python_work中，则可以使用绝对路径进行查找

   file_path = '/home/ehmatthes/other_files/text_files/filename.txt'
   with open(file_path) as file_object:
   

   此代码提供了完整的路径

   （3）逐行读取

   >>> filename = 'pi_digits.txt'
   >>> with open(filename) as file_object:
   >>>     for line in file_object:
   >>>         print(line.rstrip())    #rstrip()可以消除原始结果每行后的空白行
   3.1415926535
    8979323856
    2643383279
   

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

   >>> filename = 'pi_digits.txt'
   >>> with open(filename) as file_object:
   >>>    lines = file_object.realines()
   >>> pi_string = ''
   >>> for line in lines:
   >>>     pi_string += line.strip()   #strip()可以消除原始结果每行的前后空白
   >>> print(pi_string)
   3.141592653589793238562643383279
   

2. 写入文件

   >>> filename = 'programming.txt'
   >>> with open(filename,'w') as file_object:
   >>>    file_object.write("I love programming.\n")
   >>>    file_object.write("I love creating new games.\n")
   I love programming.
   I love creating new games.
   

   调用open( )时提供两个实参，第一个是要打开的文件的名称，第二个则是告诉Python进行的模式，可指定读取模式（‘r’）、写入模式（‘w’）、附加模式（‘a’）或读写模式（‘r+’）。如果省略了模式实参，Python将以默认的只读模式打开文件

   注意：Python只能将字符串写入文本文件，如果要将数值数据存储到文本文件中，必须先使用函数str( )将其转换为字符串格式

   写入模式会再返回文件对象前清空该文件的内容，如果想在文件后直接添加内容而不是覆盖原有的内容，可以以附加模式打开文件

3. 异常

   （1）处理ZeroDivisionError异常

   ① 使用try-except代码块

   try:
       print(5/0)
   except ZeroDivisionError:
       print("You can't divide by zero!")
   

   ② 使用else代码块

   代码块
   print("Give me two numbers,and I'll divide them.")
   print("Enter 'q' to quit.")
   while True:
       first_number = input("\nFirst number: ")
       if first_number == 'q':
           break
       second_number = input("Second number: ")
       if second_number == 'q':
           break
       try:
           answer = int(first_number) / int(second_number)
       except ZeroDivisionError:
           print("You can't divide by 0!")
       else:
           print(answer)
   

   （2）处理FileNotFoundError异常

   读取一个不存在的文件：

   filename = 'alice.txt'
   try:
       with open(filename,encoding='utf-8') as f:
           contents = f.read()
   except FileNotFoundError:
       print(f"Sorry,the file {filename} does not exist.")
   

   （3）分析文本

   这里将使用方法split( )，这里以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中

   >>> title = "Alice in Wonderland"
   >>> title.split()
   ['Alice','in','Wonderland']
   

   下面将分析多本书

   def count_words(filename):
       try:
           with open(filename,encoding='utf-8') as f:
               contents = f.read()
       except FileNotFoundError:
           print(f"Sorry,the file {filename} dose not exist.")
       else:
           words = contents.split()
           num_word = len(words)
           print(f"The file {filename} has about {num_words} words.")
   filnames = ['alice.txt','siddhartha.txt','moby_dick.txt','little_women.txt']
   for filename in filenames:
       count_words(filename)
   

   （4）静默失败

   def count_words(filename):
   try:
       --snip--
   except FileNotFoundError:
       pass
   else:
       --snip--
   

   pass语句将什么都不会发生，没有traceback，也没有任何输出

4. 存储数据

   （1）使用json.dump( )和json.load( )

   ① json.dump( )

   import json
   numbers = [2,3,5,7,11,13]
   filename = 'numbers.json'
   with open(filename,'w') as f:
       json.dump(numbers,f)
   

   以上将numbers列表存储于numbers.json文件中

   ② json.load( )

   import json
   filename = 'numbers.json'
   with open(filename) as f:
       numbers=json.load(f)
   print(numbers)
   

   以上将numbers.json中的数据读取出来

   （2）保存和读取用户生成的数据

   import json
   try:
       with open(filename) as f:
           usename = json.load(f)
   except FileNotFoundError:
       username = input("What is your name?")
       with open(filename,'w') as f:
           json.dump(username,f)
           print(f"We'll remember you when you come back,{username}!")
   else:
       print(f"Welcome back,{username}!")
   

   （3）重构

   你经常会遇到这样的情况：代码能够正确的运行，但通过将其划分为一系列完成具体工作的函数，还可以改进。这样的过程称为重构，其可以让代码更清晰、更易于理解、更容易扩展

   import json
   def get_stored_username():
       filename = 'username.json'
       try:
           with open(filename) as f:
               username = json.load(f)
           except FileNotFoundError:
               return None
           else:
               return username
   def get_new_username():
       username = input("What is your name?")
       filename = 'username.json'
       with open(filename,'w') as f:
           json.dump(username,f)
       return username
   def greet_user():
       username = get_stored_username()
       if username:
           print(f"Welcome back,{username}!")
       else:
           username = get_new_username()
           print(f"We'll remember you when you come back,{username}!")
   greet_user()