python自学笔记（一）：基础语法，萌新入！

本文链接：https://blog.csdn.net/holhouse_0628/article/details/132763045

一，基础语法

1.1 标识符/保留字

标识符：用于识别类，变量，函数，序列，元祖，字典，函数以及其他对象的名字：包含字母，数字，下划线
保留字：即为已经被python赋予特定含义的单词集合

1.1.1 保留字一览

False	逻辑值：假
None	永远表示False
True	逻辑值：真
and	逻辑运算符：与
or	逻辑运算符：或
not	逻辑运算符：非
if	条件语句
elif	条件语句
else	条件语句
for	循环语句
while	循环语句
break	中断循环
continue	继续执行下一次循环
class	定义：类
def	定义：函数
import	导入：包
from	导入：模块
global	定义：全局变量
nonlocal	函数中使用外层变量
return	函数返回
pass	空的类，函数，方法的占位符
in	判断：变量是否在序列中
is	判断：变量是否为某个类的实例
lambda	匿名函数
assert	断言，判断条件是否为
async	声明：函数为一步函数
await	声明：程序挂起
as	与with一起使用，简化表示
with	简化表示
yield	用于函数依次返回值
finally	异常：出现异常后，始终执行finally包含的代码
try	异常：包含可能会出现异常的雨具
except	异常：包括捕获异常后的操作代码
raise	异常：异常抛出操作
del	删除

1.2 变量和数据类型

1.2.1 变量

变量特点：
- 无需声明
- 使用前必须赋值，赋值以后才会创建

变量赋值：

a=b=c=1.234 #允许一次赋值多个变量
a,b,c=1,2.2,'hello' #允许多个对象指定多个变量

1.2.2 数据类型

1.2.2.1 数字：

int：整型数
float：浮点数
bool：布尔类型
complex：复数（a+bj）

1.2.2.2 字符串：’ ’

string：字符串
python没有字符类型（即char，字符就是长度为1的字符串）

字符串内容不可修改

str='abcdefg'
str[2:5] # 截取'cdef'
str*2 # 倍乘'abcdefgabcdefg'
str+"hijk" #拼接 'abcdefghijk'

1.2.2.3 列表：[ , ]

列表：有序的对象集合
列表中元素类型可以不同
支持列表嵌套

列表内容可以修改

list = [1,'abc',1.23]
list[1:] # 截取['abc',1.23] 
list*2 # 倍乘
list+['sdf'] #拼接 [1,'abc',1.23,'sdf']
### 列表内置方法
list.append(element) # 末尾添加元素

列表内置函数：

append()	列表末尾添加一个新元素
claer()	清除列表元素
copy()	复制并创建一个新列表
count(element)	统计列表中某个元素的数量
extend()	列表末尾添加一个新序列
index(element,start,end)	返回元素位置
insert(index,obj)	在对象中插入列表
pop(index)	列表移除某个元素
reverse()	反向列表元素
sort()	同类型列表排序
cmp(L1,L2)	比较两个列表
len(L1)	返回元素个数
max(L1)	返回元素最大值
min(L1)	返回元素最小值
list(tuple)	元祖转列表
remove(element)	移除列表内某一种元素

1.2.2.4 元组：（，）

元组内容不可修改
元组写在小括号里，其余操作与字符串类似

元祖内置函数

count(element)	统计元祖中某个元素的数量
index(element,start,end)	返回元素位置
cmp(T1,T2)	比较两个元祖
len(T1)	返回元素个数
max(T1)	返回元素最大值
min(T1)	返回元素最小值
tuple(list)	列表转元祖

1.2.2.5 集合：{ ，}

集合set是一个无序不重复的序列
基本功能：进行成员关系测试和删除重复元素

声明：

set={'qasd','asd','xc'}
Set() # 空集合必须用Set()函数声明
set(list)

集合内置函数：

add(element)
clear
copy
difference(set2)	计算两个集合的差集，返回一个集合：集合元素为当当前集合减去指定集合
difference_update(set2)	计算两个集合的差集，把差集赋值给原来的集合
discard(element)	移除指定元素
intersection(set2)	返回一个新的交集
intersection_update(set2)	交集赋值给前面的集合
isdisjoint(set2)	判断交集是否为空
issubset(set2)	判断集合是不是指定集合的子集
issuperset(set2)	判断集合是不是指定集合的父集
pop	删除一个元素，并返回值
remove(element)	集合中删除指定元素，没有，报错
symmetric_different(set2)	返回互为差集的合集，对称差集。
symmetricdifferentupdate(set2）	返回互为差集的合集，对称差集，赋值给前面的集合
union(set2)	返回两个集合的并集
update(set2)	求并集，赋值给前面的集合

1.2.2.6 字典：{ ：，：}

字典：是一个无序的对象集合（与列表相对应）
字典是一种映射类型：他是一个无序的键key：值Value对集合
key键必须使用不可变类型

同一个字典中，key键值必须唯一

dic={'name':'zyh','age':'23'}
dic.keys() # 输出所有键
dic.values() # 输出所有值
dic={} #创建空字典

字典删除方法

del d['name'] # 删除键为name的值value
d.clear() # 删除字典d中所有条目
del d # 删除字典
d.pop('name') # 删除并返回键为name的值value

字典内置函数

clear()	删除字典所有元素
copy()	返回字典一个副本
fromkeys(keys,value=None)	创建并返回一个新字典
get(key,default=None)	返回字典键key对应的值
item()	以列表返回可遍历（key，value）数组
keys()	返回一个包含字典中键的列表
pop(key[,default])	删除指定键key对应的值，返回值为对应的值
popitem()	随机返回，并伤处字典中一对键和值
setdefault(key,default=None)	返回字典键key对应的值
update(d2)	将另一个字典的键和值添加到原字典中
values()	返回一个包含字典中值的列表

列表，元组，字典，集合的区别

	是否有序	符号	能否重复	是否动态扩展：创建后是否可以动态地改变	元素访问	可否嵌套
列表	有	[ ]	能	是	偏移读取	可以
元组	有	( )	能	否	偏移读取	可以
字典	无	{key:value}	能	是	键读取	可以
集合	无	{ }	不能	是	不能读取	不可以

1.2.3 数据类型转换

1.3 基本控制结构

1.3.1 条件语句

1.3.1.1 if条件语句

if 条件1：
	执行1
elif 条件2：
	执行2
else：
	执行3

python没有switch-case语句

1.3.2 循环语句

1.3.2.1 while循环

count=0
while count<5:
    count=count+1
else:
    代码块

1.3.2.2 for循环

a=['y','n','s']
for i in a:
    代码块

for和while的区别：
1. for 循环是用于遍历一个已知长度的可迭代对象，而 while 循环通常用于在条件满足时反复执行一段代码。
2. for 循环是基于迭代次数的，而 while 循环是基于条件判断的。这意味着在使用 for 循环时，你需要知道要循环多少次，而在使用 while 循环时，你可能不知道循环次数，只能在循环体内部根据条件来控制何时退出循环。
3. for 循环通常用于遍历集合中的元素，而 while 循环通常用于在满足特定条件时执行一段代码块。
for可以用break跳出循环体

1.3.2.3 range函数

遍历数字序列函数

for in range(10):

1.3.2.4 break、continue语句

break：跳出循环体
一旦跳出任何else将不会执行
continue：跳出当前循环快的剩余语句，执行下一轮循环

1.3.2.5 enumerate()函数：遍历

在迭代过程中同时获取元素的索引和值

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)
# 返回一个枚举对象，每次迭代都会返回一个包含索引和对应元素的元组

1.3.3 运算符

+，-，，/，%，*，//	算术运算符：加减乘除，求余，求幂，求整除
==，！=，>，<，<=，>=	关系运算符：相等，不等，大于，小于，小于等于，大于等于
=，+=，-=，=，、=，%=，*=，//=	赋值运算符：+=相当于自加
&，\|，^，~,<<,>>	位运算符：与，或，异或，取反，左移，右移
and，or，not	逻辑运算符：与，或，非
in，not in	成员运算符：x in y：x是否在序列y中
is，not is	身份运算符：判断两个标识符是否引用自一个对象

1.3.4 函数

1.3.4.1 定义

def 函数名（参数列表）：
	函数体

函数代码以def开头，最后要标冒号
return表达式阶数函数，将一个值返回给调用方，不带return代表返回none

1.3.4.2 调用

必须先定义，再调用

1.3.4.3 参数传递

python中，变量没有类型
python中，类型属于对象

a=[1,2,3,4,5]
# [1,2,3,4,5]是一个对象，他的类型是list
# a是一个变量，他没有类型

必要参数：调用时的参数必须和声明时的参数数量一样
关键字参数：在定义函数时，可以通过在参数名前面加上默认值，将其设置为关键字参数，如果不提供参数，将会使用默认值

在函数调用时，通过key=value的形式传递给函数的参数称为关键字参数

不定长参数：函数能处理比当初声明更多的参数

在函数内部，这些参数会被视为一个元组（对于不带关键字的不定长参数）或者一个字典（对于带关键字的不定长参数）。

不带关键字：*args

def my_function(*args):
    for arg in args:
        print(arg)
my_function(1, 2, 3, 4, 5)

带关键字：**kwargs

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
my_function(name="John", age=30, city="New York") # name，age就是关键字

1.3.4.4 可更改不可更改

字符串，元祖，数字：不可更改：值传递

a=10
a=8 # 10这个对象被丢弃，a变量不是被修改，而是重新生成

列表，字典：可改变：引用传递

a=[1,2,3]
a[2]=4 #只修改了list a的部分值

1.3.4.5 匿名函数

创建小型、一次性的函数的方法
创建：lambda保留字，而非def

主体：表达式，而非代码块

lambda[arg1 [,arg2,..]]:表达式
sum = lambda arg1,arg2:arg1+arg2

1.3.5 变量作用域

种类：查找顺序：L>E>G>B
- 局部作用域L
- 闭包函数外的函数中E
- 全局作用域G
- 内建作用域B
python只有模块module，类class，函数def，lambda会引入新的作用域
全局变量：定义再函数外的变量（全局作用域）
局部变量：定义再函数内的变量（局部作用域）

作用域的修改：global，nonlocal关键字

global：
```
global num # 声明
```

nonlocal：用于指示一个变量不是局部变量，也不是全局变量，而是在封闭作用域中的变量

作用：想对一个嵌套作用域（比如在另一个函数内）中的变量进行赋值，但又不想将其视为新的局部变量

def outer_function():
    x = 10

    def inner_function():
        nonlocal x  # 声明x是外部函数的变量，而不是创建一个新的局部变量
        x = 20  # 修改了outer_function()中的x

    inner_function()
    print(x)  # 输出 20

1.3.6 with 语句

作用：是 Python 提供的一种简洁处理文件打开、线程锁定等资源管理的方式。它能够保证在程序执行完毕后自动关闭文件

with open('file.txt', 'r') as file:
    content = file.read()
    # 在这里对文件进行读取和处理
# 在这里文件会自动关闭

1.3.7 字符串操作

字符串创建：单引号’ '，双引号" "

1.3.7.1 访问字符串中的值

a='ASDAF'
a[-1] #'F'
a[2:4] #'DAF'

1.3.7.2 字符串运算符

a='ASDAF'
b='QWE'
a+b # 'ASDAFQWE'
b*2 # 'QWEQWE'
"A" in a # TRUE

1.3.7.3 字符串内置函数

capitalize()	将字符串第一个字换成大写
casefold()	所有大写字符换成小写字符
center((with[, fillchar]))	返回一个原字符串居中，并使用指定字符串填充至长度的新字符串
count(sub, start, end)	返回子字符串出现的次数
encode(encoding=‘UTF-8’)	以encoding指定的编码格式编码字符串
endswith(suffx[, start[, end]])	判断是否以指定后缀结尾
expandtabs()	把tab转换为空格
find(str)	检查字符串是否包含子字符串
isalnum()	检查字符串是存在数字
split(str)	指定分隔符对字符串进行切片，即切割掉一部分，并把分开的部分存入列表
strip()	去掉开头结尾的空格
replace(old,new)	旧字符串换成新的
partition(str)	指定分隔符对字符串进行切片，但不割掉一部分，并把分开的部分存入列表
translate(table)	根据table给出的映射表替换字符串的字符

# 使用 maketrans 生成转换表
table = str.maketrans('aeiou', '12345')  # 将元音字母映射为数字

string = "hello world"
result = string.translate(table)

print(result)  # 输出: h2ll4 w4rld

1.3.8 异常

异常是一个事件，在程序执行中发生，影响程序正常执行

1.3.8.1 捕获异常

try-expect-else语法

try:
	<语句0>
except<异常名字1>:
    <语句1> #如果try引发了name1异常，执行
except<异常名字2>：
	<语句2>
else:
    <语句3> #没有发生异常，执行
finally:
    <语句4> #无论发不发生异常都执行

工作原理：
- 开始一个try语句后，当有异常出现时，返回这里，让try的子句执行
- try后的语句发生异常，跳回try并执行第一个匹配异常的子句
- 如果子句执行时没有发生异常，执行else后的语句

1.3.8.2 常见异常

Exception：所有内建异常的基类。通常不直接使用，而是使用特定的异常类型。
SyntaxError：语法错误，通常在代码编写时引发，表示代码不符合Python语法规则。
IndentationError：缩进错误，指示缩进不正确，通常与代码块的缩进有关。
NameError：名称错误，通常在尝试访问一个未定义的变量或函数时引发。
TypeError：类型错误，表示操作或函数应用于不适当类型的对象时引发。
ValueError：数值错误，当一个函数收到一个具有正确类型但值不合适的参数时引发。
ZeroDivisionError：除零错误，当尝试除以零时引发。
FileNotFoundError：文件未找到错误，尝试打开一个不存在的文件时引发。
IOError：输入/输出错误，通常与文件或数据流的读写操作相关。
IndexError：索引错误，尝试访问一个不存在的列表索引或切片时引发。
KeyError：键错误，尝试使用字典中不存在的键时引发。
AttributeError：属性错误，尝试访问对象不存在的属性时引发。
ImportError：导入错误，通常在尝试导入不存在的模块或包时引发。
AssertionError：断言错误，通常在 assert 语句失败时引发，用于测试代码的正确性。
RuntimeError：运行时错误，通常用于指示未捕获的异常。
KeyboardInterrupt：键盘中断，通常通过用户按下键盘中断键（Ctrl+C）引发，用于中止程序执行。
EOFError：文件末尾错误，通常在输入操作尝试读取文件末尾时引发。
MemoryError：内存错误，表示程序尝试分配超过可用内存的资源。

1.3.8.3 抛出异常

raise语法：自己触发异常

raise [ExceptionType [arguments]]
# ExceptionType 是要引发的异常类型，通常是一个内建的异常类（如 ValueError），或者是自定义的异常类
# arguments 是异常的参数，可以是一个值或一个元组，具体取决于异常类的定义

1.3.8.4 自定义异常

你可以通过创建一个新类来定义自己的异常。这个类必须继承自内建的 Exception 类。

class MyError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)
try:
    raise MyError("自定义异常被触发了")
except MyError as e:
    print(e)