devStandard/docs/learning/9-python/1-python基础语法.md

Python基础语法

第一个程序

print("hello word")

数据类型

• 数字 Number
  • 整数 int
  • 浮点数 float
  • 复数 complex 4+3j
• 布尔 bool
• 字符串 String : 用单引号或者双引号包裹, 或者三对双引号 """字符串"""
• 列表 List : 有序的可变序列
• 元组 Tuple : 有序的不可变序列
• 集合 Set : 无序不重复集合
• 字典 Dictionary : 无序key-value集合

type(1) : 检查类型

注释

# 单行注释

'''
三个单引号多行注释
'''

"""
或者三个双引号
"""

风格

代码块

===不使用{}, 而是缩进表示代码块. 同一个代码块缩进的空格数必须一致===

if True:
  print("true")
else:
  print("false")

多行语句

# 用 \ 实现换行
total = one + two + \
        three + four

# 在 [] {} 中不需要 \
total = [one , two 
		three, four]

保留字

import keyword
print(keyword.kwlist)

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

变量

# 语法: 
变量名 = 变量值

数据类型转换

int(x)
float(x)
str(x)

标识符

• 内容限定: 英文 数字 下划线, ===数字不能在空头===
• 大小写敏感
• 不可使用关键字, 关键字也是大小写敏感

变量命名规范: 蛇形命名法: ===全小写, 下划线===

运算符

• 算数运算符
  • • • • /
  • // 取整除 : 9//2输出4
  • % 取余
  • ** 指数
• 赋值运算符
  • =
  • += -= *= /= //= %= **= 复合赋值运算符

===没有 ++ -- ===

字符扩展

• \ 转义
• 拼接: 加号, 只能用字符串拼字符串
• 占位格式化

"""
语法:
%s在字面量中占位, 后面 % 变量
顺序不能变

%s 字符串
%d 整数
%f 浮点数
"""


name = "张三"

age = 18

message1 = "%s是男性" % name

message2 = "%s今年%d岁了" % (name, age)

print(message1,message2)

• 格式化的精度控制

"""
m.n m表示宽度, n表示小数的精度

# 示例
%5d   # 宽度控制为5, 少的宽度用空格补全; 如果宽度小于实际, 不生效; 宽度包含小数和小数点
%5.2f # 宽度为5, 两位小数, 小数部分4舍5入
%.2f  # 不限制宽度, 只限制小数
"""

num = 11.456

print("%7d" % num)   #      11
print("%7.2f" % num) #   11.46
print("%.2f" % num)  # 11.46

• 快速格式化

# f"内容{变量}"
# 没有类型和精度控制
# f format

name = "张三"
age = 18.5
message = f"{name}今年{age}岁了"
print(message)

• 格式化中使用表达式

print("11的类型是%s" % type(11))

print(f"11的类型是{type(11)}")

数据输入

"""
input() 接收键盘输入
input("提示文本")
获取的是字符串格式,其他格式需要自行转换
"""

name = input("请输出你的名字")
print(f"name: {name}")

判断语句

• 比较运算符:

>
<
==
!==
>=
<=

• 布尔类型: True False ===大写===
• if 语句

if 条件:
  执行语句

• if else 语句

if 条件:
  执行语句
else:
  执行语句

• if elif else

if 条件:
  执行语句
elif 条件:
  执行语句
else:
  执行语句

• 嵌套

# 关键 缩进
if 条件:
  执行语句
  if 条件:
    执行语句

while 循环

while 条件:
  执行语句

• 嵌套

while 条件:
  执行语句
  while 条件:
    执行语句

for in 循环

for 临时变量 in 序列类型
  执行的代码

str="hello word"
for i in str:
  print(i)

• 嵌套

for 临时变量 in 序列类型
  执行的代码
  for 临时变量 in 序列类型
    执行的代码

range 语句

生成数字序列

# 生成一个从0开始到num的数字序列, 不包含num本身
range(num)

range(5)
# [0, 1, 2, 3, 4]


# 从 num1 到num2, 不包含num2
range(num1, num2)

# 从num1到num2, 步进为step
range(num1, num2, step)

range(2, 7, 2)
# 2, 4, 6

使用场景:

for x in range(10):
  print(x)

print 控制是否换行

print("", end=""), end参数控制输出的结尾内容, 而不是默认换行

99乘法表

for i in range(1,10):
  for j in range(1,i+1):
    print(f"{i}*{j}={i*j} \t",end="")
  print()

continue 和 break

continue 临时跳过

break 结束

示例:

for x in range(1, 6):
  if x == 3:
    continue
  print(x)

for x in range(1, 6):
  if x == 3:
    break
  print(x)

函数

def 函数名(形参):
  函数体
  return 返回值

# 调用
函数名(实参)

函数注释

def 函数名(x, y):
  """
  函数说明
  :param x: 行参x的说明
  :param y: 行参y的说明
  :return: 返回值的说明
  """
  函数体
  return 返回值

示例:

def add(num1, num2):
    """
    这是一个计算两个数相加的函数
    :param num1: 第一个数
    :param num2: 第二个数
    :return: 两个数相加的结果
    """
    return num1 + num2

print(add(1,2))

列表

变量名 = []

变量名 = list()

变量名 = [元素1, 元素2, ...]

下标索引

# 从0开始
变量名[下标]

# 反向索引
# 从-1开始
变量名[-1]

# 嵌套列表
变量名[0][0]

常用方法

• 增:
  • 插入: 列表.insert(下标, 值)
  • 追加: 列表.append(值)
  • 把列表内容取出追加到列表: 列表1.extend(列表2)
• 删:
  • del 列表[下标]
  • 被取出的元素=列表.pop(下标)
  • 列表.remove(元素):从前到后第一个匹配项
  • 列表.clear(): 清空
• 改: 列表[下标]=新的值
• 查: 查询下标 列表.index(元素)
• 统计元素个数: 列表.count(元素)
• 长度: len(列表)

列表的遍历

• while

list = ["a", "b", "c"]
index = 0
while index < len(list):
  print(len[i])
  index+=1

• for in

list = ["a", "b", "c"]
for x in list:
  print(x)

元组

只读的列表, 定义完成, 不能修改

元组 = (元素1, 元素2, ...)

元组 =  tuple()

===只有一个元素的元组, 必须带逗号===

元组 = (元素1, )

下标索引

t1 = ((1, 2, 3), (4, 5, 6))
element = t1[1][2]
print(element)

方法

• 查: 元组.index(元素)
• 统计:
  • 元素的数量 元组.count(元素)
  • 长度: len(元组)

遍历

while

for in

修改

t2 = ((1, 2, 3), [4, 5, 6])
t2[1][2] = 7 # 元组里的数组里的元素可以修改
print(t2)

字符串

str = "hello word"
print(str[0])
print(str[-1])

===字符串是不可修改的数据容器===

常用的方法

• 字符串.index(字符)
• 替换: 不是修改, 是得到新的字符串 newstr = 字符串.replace(字符1, 字符2)
• 分割: 列表 = 字符串.split(用来分割的字符)
• 去首尾空格: newstr = 字符串.strip()
• 去指定字符: newstr = 字符串.strip(要去除的字符)
  • ===去除是逐个去除=== print("12hello word21".strip("12")), 结果是 hello word, 不止12被去除了,21也被去除了
• 统计次数: count = 字符串.count(字符)
• 长度: num = len(字符串)

序列的切片

列表 元组 字符串 都支持切片 对序列切割不影响序列本身, 而是返回新的序列

序列[起始:结束:步长]
# 起始为空, 表示从头开始
# 结束为空, 表示到尾. 不为空, 到该下标结束, 不包含该下标所在的元素
# 默认为1,可省略, 表示连续取；为n, 表示跳过n-1个; 为正, 表示从左到右; 为负, 表示反方向(下标也得反方向).

示例:

print([1, 2, 3, 4, 5, 6, 7, 8, 9][1:7])
# 输出[2, 3, 4, 5, 6, 7]

print([1, 2, 3, 4, 5, 6, 7, 8, 9][1:7:2])
# 输出[2, 4, 6]

print([1, 2, 3, 4, 5, 6, 7, 8, 9][1:7:3])
# 输出[2, 5]

print("1234567"[::-1])
# 7654321

集合

# 集合不支持重复, 自带去重
new_set = {元素1, 元素2, ...}

new_set2 = set()

===不支持下标索引访问===

常用的方法

# 增
集合.add(元素)

# 删
集合.remove(元素)

# 随机取出一个元素, 同时集合被修改, 该元素被移除
集合.pop()

# 清空
集合.clear()

# 差集, 集合1 集合2不变, 得到集合1有集合2没有的
新集合 = 集合1.difference(集合2)

print({1, 2, 3}.difference({3, 4, 5}))
# 输出 {1, 2}

# 消除差集, 集合1被修改, 集合2不变, 在集合1内删除和集合2相同的内容
集合1.difference_upate(集合2)

my_set={1, 2, 3}
my_set.difference_update({3, 4, 5})
print(my_set)

# 集合合并, 集合1 集合2不变, 返回合并后的集合
集合1.union(集合2)

print({1, 2, 3}.union({3, 4, 5}))

# 长度
len(集合)

遍历

没有下标, 不支持 while, 但可以用for in

字典

{key1: value1, key2: value2, ...}

emy_dict = {} # 不是集合
# 或者
emy_dict = dict()

# 取出值
字典[key]

===key不能是字典===

常用方法

新增/更改

# 不存在就是新增, 已存在就是更改
字典[key] = value

删

# 取出来的同时, 也从原字典中删除
value = 字典.pop(key)

清空

字典.clear()

获取所有的键

keys = 字典.keys()

长度

len(字典)

遍历

方法一:

dict = {"name": "张三", "age": 18, "address": "北京"}
for key in dict.keys():
  print(dict[key])

方法二:

dict = {"name": "张三", "age": 18, "address": "北京"}
for key in dict:
  print(dict[key])

数据容器的通用操作

1. 遍历
2. len(容器)
3. max(容器) 最大元素
4. min(容器) 最小元素
5. 容器转换
   1. list(容器) 字典转列表, 会只保留key
   2. str(容器)
   3. tuple(容器)
   4. set(容器)
6. 通用排序: sorted(容器, [reverse=True]) 把内容排序后放到列表中

字符串比较大小

数字 字符 是如何比较大小的: 按照ASCII的码值

比较的时候是一位位从左到右比较的, 只要有一位大, 就整体大

函数

返回多个值

# 用逗号隔开
def test():
  return 1, 2
a, b = test()
print(a, b)

关键字传参

# 位置传参
def sum(num1, num2):
  return num1 + num2

sum(1, 2)

# 关键字传参
# 键=值
# 顺序可以打乱
sum(num2=1, num1=2)

# 还可以混用, 但位置传参在前, 关键字传参在后

缺省/默认参数

===默认参数必须写到最后面===

def user_info(name, age, gender="男"):
  print(name, age, gender)

可变参数

# 位置传递
# 一个星号
# 传递的所有参数都会被args收集, 合并成一个元组
def user_info(*args):
  print(args)

user_info("张三", 18,"男")
# ('张三', 18, '男')

# 关键字传递
# 两个星号
# 参数必须是键值对的形式
# 字典
def user_info(**kwargs):
  print(kwargs)

user_info(name="张三", age=18, gender="男")
# {'name': '张三', 'age': 18, 'gender': '男'}

lambda 匿名函数

# 函数体只能写一行
lambda 参数: 函数体

def test(fn):
  res = fn(1, 2)
  print(res)

test(lambda x, y: x + y)

文件操作

文件编码

• UTF-8
• GBK
• Big5

文件的打开

open(name, mode, encoding)
# name 文件名或路径
# mode r只读  w写入  a追加 
# encoding 编码格式, 常用UTF-8

f = open("test.txt", "r", encoding="utf-8")
print(type(f))

# <class '_io.TextIOWrapper'>

读取

• read([num]): 不传参时读取所有；传参时, 读取 num 字节
• readlines(): 读取全部行, 依次存到列表中
• readline(): 一次读取一行

注意: 如果多次调用 read() 方法, 会记录上次读取的位置, 例如:

f = open("test.txt", "r", encoding="utf-8")

print(f.read(2))
print(f.read())
# 从第三个字节开始读取
print(f.readlines())
# 为空

• for in 循环读取文件

for line in open("test.txt",  "r", encoding="utf-8"):
  print(line)

关闭

# 结束对文件的占用
f = open("test.txt", "r", encoding="utf-8")
f.close()

with open() as f 语法会自动关闭

示例:

with open("test.txt", "r") as f:
  f.readlines()

写入

f.write("写入的内容")

# 内容刷新, 从内存写入到硬盘
# 好处是避免频繁操作硬盘
f.flush()

示例:

# w 模式
# 当文件不存在时, 创建该文件
# 当文件存在, 会清空
f = open("test.txt", "w")
f.write("hello word\n")
f.write("123")
f.flush()
f.close()

# close()方法内置了 flush(), 关闭时也会自动写入硬盘

追加

# a 模式
f = open("test.txt", "a")

异常的捕获

try:
  可能发生错误的代码
except:
  如果出现错误执行的代码

示例:

try:
  f = open("none.txt","r")
except:
  print("文件不存在")

捕获指定的异常

try:
  可能发生错误的代码
except 异常的类型 as e:
  如果异常类型符合就执行
  e是异常信息

示例:

try:
  print(name)
except NameError as e:
  print(e)

捕获多个异常

# 用元组来指定异常类型
try:
  可能发生错误的代码
except (类型1, 类型2, ...) as e:
  如果异常类型符合就执行
  e是异常信息

示例:

try:
  print(1/0)
except (NameError,ZeroDivisionError) as e:
  print(e)

捕获所有异常

# except 不指定类型就可以捕获所有异常

# 也可以指定类型 Exception
try:
  可能发生错误的代码
except Exception as e:
  如果异常类型符合就执行
  e是异常信息

示例:

try:
  print(name)
except Exception as e:
  print(e)

主动抛出异常

raise Exception("异常消息")

else

try:
  可能发生错误的代码
except Exception as e:
  如果异常类型符合就执行
  e是异常信息
else:
  没有异常时执行的代码

finally

try:
  可能发生错误的代码
except Exception as e:
  如果异常类型符合就执行
  e是异常信息
else:
  没有异常时执行
finally:
  无论如何都要执行

异常的传递

# 异常会一层层往外传
# 只要函数具有调用关系, 只须在最顶级捕获异常
def fun1():
  print(name)

def fun2():
  fun1()

def main():
  try:
    fun2()
  except Exception as e:
    print(e)

main()

模块

导入

[from 模块名] import [模块|类|变量|函数|*] [as 别名]

import 模块名
模块名.函数()

import 模块名1, 模块名2

示例:

import time

print(time.time())
time.sleep(5)
print(time.time())

from time import sleep
print(time.time())
sleep(5)
print(time.time())

# 也是导入全部
from time import *
sleep(5)

# as 别名
from time import sleep as t
t(5)

自定义模块

# 新建一个py文件
# 在该文件里写函数

# import 文件名
# 或者
# from 文件名 import 函数

• 模块导入的时候会执行模块里的语句

例如:

# module.py
def sum(a,b):
  print(a+b)

sum(1,2)

# test.py
import module
# 这里导入时就会输出3

改造:

def sum(a,b):
  print(a+b)

if __name__ == "__main__":
  sum(1,2)

# 直接运行该文件时, 内置变量 __name__ 就会设置为 __main__
# 作为模块被导入时, if 里的代码不执行

• __all__ 变量

__all__=["sum"]

def sum(a,b):
  print(a+b)

def sub(a, b):
  print(a-b)

from  module import *
# 通过*只能导入 __all__ 列出的函数
# __all__ 不定义, 就可以导入全部

包

文件夹里有多个模块

1. 创建文件夹
2. 创建 __init__.py 文件
3. 创建 模块.py
4. 使用: import 包名.模块名
   包名.模块名.函数

   或者
   from 包名 import 模块名
   模块名.函数()
   
   或者
   from 包名.模块名 import 函数
   函数()

结构:

文件夹名为包名
  __init__py
  module1.py
  module2.py

示例:

import my_package.module1
import my_package.module2

my_package.module1.sum(1, 2)
my_package.module2.sub(1, 2)

或者

from my_package import module1
from my_package import module2

module1.sum(1, 2)
module2.sub(1, 2)

from my_package.module1 import sum
from my_package.module2 import sub

sum(1, 2)
sub(1, 2)

• __all__

# 写在__init__.py
__all__ = ["module1", "module2"]

安装第三方包

pip install 包名