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

✍个人博客https://blog.csdn.net/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()