Python基础

语法

基本语法

• 字面量：在代码中，被写下来的固定的值

  • 数字 Number
    • 整数 int
    • 浮点数 float
    • 复数 complex
    • 布尔 bool
  • 字符串 String
  • 列表 List：有序的可变序列
  • 元组 Tuple ：有序的不可变序列
  • 集合 Set
  • 字典 Dictionary：无序Key-Value集合

• 注释：

  • 单行注释： #
  • 多行注释： “”“注释内容”“”“ （即一对三个引号）

• 变量： python的变量没有类型，使用时直接 ： 变量名 = 赋值数据

• 数据类型：

  使用 type() 可以查看数据类型

• 标识符： 对变量、方法、类等起的名字就是标识符。

  标识符中不可出现关键字，大小写敏感。

  Python的关键字有：

  False，True，None，and，as，assert，break，class，continue，def，del，elif，except，finally，for，from，global，if，import，in，is，lambda，nonlocal，not，or，pass，raise，return，try，while，with，yield

• 运算符：

  python中不一样的运算符号： ** 是求平方

• 字符串扩展：

  • 字符串三种定义方式：单引号，双引号，三引号

  • 引号嵌套：使用 \ 进行转义，或单引号内写双引号、双引号内写单引号。

  • 字符串的拼接： 使用 + 号

  • 字符串格式化： ”%占位符“ % 变量， 例如：”%d“ % num；

    精度控制：

    1. 使用：**%m.n占位符**
    2. 使用： f ”{变量} {变量}“ —— 这种方式不理会类型，不做精度控制，在对精度没要求时可以快速使用。

• 数据输入：input（）

  例：变量名 = input() ， input（提示信息），括号内的提示信息可以在输入内容前显示。

• 判断语句

  if 条件1:
      代码。。。
  elif 条件2:
      代码。。。
  else:
      代码。。。

• 循环语句

  while 条件:
      。。。。
      。。。。

  for 临时变量 in 待处理的数据集:
      代码。。。
      
  # 例: 依次取出字符串的每一个字符
  name = "i am Tom"
  for x in name:
      print(x)

  for循环无法定义循环条件，只能被动取出数据处理

  range(num) 可以获得一个简单的数字序列

  • range(num1，num2) 获得一个从num1开始，num2结束的数字序列（不含num2）
  • range(num1，num2，step) 获得一个从num1开始，num2结束的数字序列（不含num2），数字之间步长为step

  for i in range(3):
      print(i)
  # 打印结果
  0
  1
  2
  
  for i in range(1,7,2):
      print(i)
  # 打印结果
  1
  3
  5

  for语句中的临时变量 在规范上只作用于for循环内部，但在for循环外仍能访问到这个临时变量，不过从规范上不要这么做。

函数

函数定义：

def 函数名(传入参数):
    函数体
    return 返回值
#先定义函数，后调用函数
#参数和返回值如果不需要，可省略

# 例:
def add(x, y):
    result = x + y
    print(f"{x}+{y}={result}")
    return result

• 如果函数没有返回值，则默认返回 None，表示空的、无意义的。 在判断条件中，None等同于False。

  如果需要多个返回值，则使用逗号隔开，接受时也用多个变量进行接受。

  def test():
      return 1, 2
  
  x, y = test()

• 在函数内定义的变量如果需要声明为全局变量，可使用global关键字，如：

  num = 0
  
  def add(x, y):
      num = x + y	#函数内定义的局部变量，不影响全局变量num
      
  def add2(x):
      global num	#声明为全局变量，会影响到全局变量num
      num += x

• 函数传参 参数种类

  • 位置参数： 形参和实参的顺序和个数一致

  • 关键字参数：参数调用时通过键值对来传递参数（如果有位置参数的话，位置参数要在关键字参数前面）

    def test(name, age, gender):
        print(f"姓名:{name},年龄:{age},性别:{gender}")
    
    test(name="tom", gender="男", age=1)
    test("tom", age=1, gender="男")  #位置参数仍然需要放在相应的位置上

  • 缺省参数：为参数提供默认值，传参时可不用传递这个参数，

    def test(name, age, gender="男")

  • 不定长参数：不确定会传入多少参数，分为：

    • 位置传递： 传入的参数会被合并为一个元组。

      def test(*args):
          print(args)
      
      test("Tom", 18)

    • 关键字传递：参数是键值对的形式，传入的参数会根据键值对组成字典。

      def test(**kwargs):
          print(kwargs)
          
      test(name="Tom", age=18)

• 匿名函数

  • 函数作为参数传递， 这是一种计算逻辑的传递，而非数据的传递

    def test(compute):
        result = compute(1,2)
        print(result)
        return
    
    def compute(x, y):
        return x + y
    
    test(compute)	# 结果 3

  • lambda表达式：只使用一次的无名称匿名函数

    格式： lambda 传入参数：函数体

    def test(compute):
        result = compute(1,2)
        print(result)
        return
    
    test(lambda x, y : x + y)	# 结果 3

容器

容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素。（每一个元素，可以是任意类型的数据，如字符串、数字、布尔等）

list 列表

# 定义列表
变量名 = [元素1, 元素2, 元素3, ...]
# 定义空列表
变量名 = []
变量名 = list()

列表中可以存不同的数据类型，支持嵌套； 最多容纳2^63-1^个元素。

列表的索引：

• 正向索引： 左边第一位为0，向右递增

• 反向索引：右边第一位为-1，向左递减

  name_list = ['tom', 'amy', 'rose']
  print(name_list[-1]) # 结果是rose
  print(name_list[-2]) # 结果是amy

列表方法：

• 列表**.index(元素)** —— 查找指定元素的下标，如果找不到，报错ValueError

  my_list = [1, 2, 3]
  print(my_list.index(2))

• 列表[下标] = 新值 —— 修改指定下标的值

• 列表**.insert (下标，元素)** —— 在指定下标处插入新元素

• 列表**.append(元素)** —— 将元素追加到列表尾部

  列表**.extend(其他数据容器)** —— 将其他容器的内容取出，依次追加到列表尾部

  my_list = [1, 2, 3]
  my_list.extend([4, 5, 6])
  print(my_list.index(2))
  #结果: [1，2，3，4，5，6]

• 列表**.pop(下标)** —— 删除元素

  del 列表[下标] —— 删除元素

  my_list = [1, 2, 3]
  
  del my_list[0]	# 结果为[2,3]
  
  my_list.pop(0)	# 结果为[2,3]

  列表**.remove(元素)** —— 删除某元素在列表中的第一个匹配项

  列表**.clear()** —— 清空列表内容

• 列表**.count(元素)** —— 统计某元素在列表中的数量

  len(列表) —— 统计列表的元素数量

  my_list = [1, 2, 3]
  print(len(my_list))

列表遍历：

• ```python
  index = 0
  while index < len(列表):
  。。。

  * ```python
    for i in 列表:
        。。。

tuple 元组

元组和列表类似，可以封装多个不同类型的元素在内，但元组在定义后，不可修改。

# 定义元组使用 小括号
变量名 = (元素, 元素, ...)
# 定义空元组
变量名 = ()
变量名 = tuple()

# 注：只定义一个元素的元组，还需要再加一个逗号,否则不是元组类型
t1 = ("hello", )

元组方法：

• 元组.index(元素)

• 元组.count(元素)

  len(元组)

元组遍历：（与列表遍历一致）

str 字符串

字符串是一个无法修改的容器，

字符串方法：

• 字符串**.index(字符串)** —— 查找特定字符串的下标

• 字符串**.replace(str1，str2)** —— 将字符串内的str1全部换成str2； 这个操作不是修改字符串，而是得到一个新字符串，原字符串不变。

• 字符串**.split(分隔符)** —— 按分隔符 分为多个字符串，并存入列表对象； 原字符串不变，新生成一个列表对象。

• 字符串**.strip()** —— 规整操作，即去除前后空格

  字符串**.strip(字符串)** —— 去除前后指定字符串（按照单个字符来去除，如传入”ab”，则前后的“1”和“2”都会去除，不讲究顺序）

• 字符串**.count(字符串)** —— 统计指定字符串出现的次数

  len(字符串) —— 统计字符串长度

序列的切片操作

序列：内容列连续、有序，可使用下标索引的一类数据容器（列表、元组、字符串）

语法： 变量名 = 序列[起始下标：结束下标：步长]

—— 从起始下标开始，截取到结束下标（不含），得到一个新序列。

—— 起始下标留空，则从头开始取；结束下标留空，则截取到末尾；步长留空，默认为1，步长若为负数，则反向取。

set 集合

集合 是 去重且无序的

# 集合定义使用大括号 {}
变量名 = {元素, 元素, ...}

变量名 = {}
变量名 = set()

集合方法：

• 集合**.add(元素)** —— 添加新元素
• 集合**.remove(元素)** —— 移除指定元素
• 集合**.pop(元素)** —— 从集合中随机取出一个元素，并该元素从集合中删除
• 集合**.clear()** —— 清空集合
• 集合1**.difference(集合2)** —— 取出集合1和集合2的差集（1有的，2没有的），得到一个新集合，原集合不变。
• 集合1**.difference_update(集合2)** —— 消除2个集合都存在的元素（在集合1中，删除和集合2相同的元素），集合1被修改，集合2不变。
• 集合1**.union(集合2)** —— 将集合1和集合2合并，得到新集合
• len(集合) —— 查看元素数量

集合遍历：

• 支持for循环
• 不支持while循环（因为集合没有下标索引，所以不能用while）

dict 字典、映射

字典存储的元素是键值对，用{}进行定义。

my_dict = {key: value, ....}
my_dict = {}
my_dict = dict()
#key不可重复，重复赋值则会覆盖原数据

字典可以通过key来查询对应的value，如： my_dict[key] 可以得到对应的value。

value也可以是字典

字典方法：

• 字典[key] = value —— 新增或更新元素
• 字典.pop(key) —— 获得指定key的value，同时从字典中删掉
• 字典.clea() —— 清空字典
• 字典.keys() —— 获得字典的全部key
• len(字典) —— 字典元素数量

字典遍历：

for key in 字典.keys:
    ...

容器的通用方法

• len(容器) —— 统计容器的元素数量

• max(容器) —— 统计容器的最大值

• min(容器) —— 统计容器的最小值

• list(容器) —— 将容器转换为列表

  tuple(容器) —— 转换为元组

  str(容器) —— 转换为字符串

  set(容器) —— 转换为集合

• sorted(容器，[reverse=True]) —— 对容器进行排序，排序后得到列表list对象，reverse=True表示降序

文件操作

• 文件编码

  编码是一种规则集合，记录了内容和二进制间进行转化的逻辑。

• 文件读取

  open() —— 打开文件

  open('文件路径', '打开方式'， 编码方式)
  #打开方式： r是只读,默认模式; w是只写入,会删除原内容; a是追加,新内容追加到已有内容之后
  #例
  f = open('python.txt', 'r', encoding="UTF-8")

  read(num) —— 读取文件，num为要读取的数据长度(字节)，如果没有num，则读取所有数据。

  readlines() —— 全部读取，返回一个列表，其中每一行数据为一个元素。

  readline() —— 读取一行数据

  flush() —— 刷新缓冲区

  close() —— 关闭文件，自动刷新缓冲区

  # 使用with open，会自动关闭文件，不用自己调用close()方法
  with open('文件路径', '打开方式') as f:
      f.readlines()

  f = open('hello.txt', 'r', encoding="UTF-8")
  print(f.read())
  
  for line in open('hello.txt', 'r'):
      print(line)

• 文件写入

  write(“写入内容”) —— 写入数据，数据会先存在缓冲区，需要调用flush()或close()才会真正写入文件。

• 文件追加

  （打开方式为 ’a‘ ）

异常

• 异常处理/捕获异常：

  try:
      可能出错的代码
  except:
      出现异常时,执行的代码
  else:
      没有异常时,执行的代码
  finally:
      无论是否异常,都要执行的代码

  # 捕获多个异常
  try:
      print(1/0)
  except(NameError, ZeroDivisionError) as e:
      print(e)
   
  # 捕获所有异常
  try:
      print(1/0)
  except Exception as e:
      print(e)

• 异常传递：异常会沿调用者向上传递，一直到main函数。如果所有函数都没有捕获异常时，程序就会出错。

模块、包、类

• 模块：就是一个python文件，以 .py 结尾； 模块能定义函数、类、变量，以此提供一些功能。

• 导入模块：

  import time		#导入时间模块
  # time.sleep(1) 使用：模块.功能()
  import time as 模块别名
  
  from time import sleep	#导入time模块的sleep方法
  from time import *
  # sleep(1)  使用：功能()
  from time import sleep as 方法别名

• _main_ 变量的功能：

  if __name__ == '__main__':

  只有当程序直接执行时， 内置变量_name__才会被赋值 ‘_main‘，才能进入if内部； 如果是被导入的，则无法进入if。

• 注：不同模块，相同的功能名，如果都被导入，那么后导入的会覆盖先导入的，即后导入的生效。

• _all_ 变量可以控制 “from xxx import *” 时导入的元素，只有在 __all__ 中声明的功能才能被导入。

  没被声明的功能依旧可以被其他导入方式所导入。

  __all__ = ['test1']
  
  def test1():
  def test2():

• python包： 相当于一个文件夹，里面有一个 _init_.py文件，用于控制包的导入行为； 还可包含多个模块。

  从逻辑上看，包的本质依然是模块，导入方式也和模块相同。

  import 包名.模块名

  可在 _init__.py文件 书写 __all_ 变量，同样用于控制模块是否导入，，

类

• 创建：

  class 类名(object):
      x = 10		#类属性
      def __init__(self, 其他参数):	#创建实例时自动调用，为实例增加实例属性
          
      def 方法名(self, 其他参数)

  • self表示类的实例，是通过类创建的实例

  • 实例属性每个实例各自拥有，互相独立；类属性有且只有一份。 如果实例属性和类属性同名，实例属性的访问优先级更高，访问到的是实例属性