python基础语法

目录

1、行与缩进，注释

2、变量声明与赋值：

3、数据类型：

基本数据类型：

整形(int)

浮点型(float)

字符串（str）

布尔型（bool）

NoneType（None）

高级/复合数据类型：

列表（list）

元组（tuple）

字典（dict）

集合（set）

4、控制结构

条件语句

循环结构

for循环语句

while循环语句

5、函数定义

6、输入/输出

7、异常处理

8、模块导入

---

1、行与缩进，注释

• 行与缩进，python最大特色，以行和缩进来表示代码块，缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：

if True:
    print("True")
else:
    print("False")
#输出：
True

        以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

if True:
    print("right，True")
else:
    print("None")
  print("Null")
#报错：
IndentationError: unindent does not match any outer indentation level

• 注释，可以通过#注释单行，也可以通过三引号'''注释内容'''、"""注释内容""" 注释多行，注释的内容不会运行，pass：如需注释多行已写好的代码，可以选中需要注释的多行代码ctrl+/，同理取消注释也是ctrl+/ 

  # 第一个注释
  # 第二个注释
   
  '''
  第三注释
  第四注释
  '''
   
  """
  第五注释
  第六注释
  """
  print ("Hello, Python!")
  
  #输出:
  Hello, Python!

2、变量声明与赋值：

标识符(变量名)必须以26个字母或者下划线 _ 开头，python3开始支持中文作为变量名，非 ASCII 标识符也是允许的了。(使用ASCII字符之外的标识符可能降低代码的可读性和跨平台移植性，因此在实际开发中，除非必要，否则通常建议优先使用ASCII字符。)

需要注意不能用关键字作为标识符(变量名)，Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

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']

在python中，不需要显式声明变量类型，当我们给一个变量赋值时，python会自动确认其类型。

x=1  #整型
y=1.12  #浮点型
c="字符串123abc"  #字符串
x=True #布尔值
中文变量=['abc',1,2,3,4] #列表

a,b,中文=1,'ab','中文值' #为多个变量赋值  a=1，b='ab'，中文='中文值'

a=b=中文=1 #同时为多个变量赋同一个值，a、b、中文三个变量的值都为1

3、数据类型：

Python有多种内置的数据类型，包括整型（int）、浮点型（float）、字符串（str）、布尔型（bool）、列表（list）、元组（tuple）、字典（dict）和集合（set）等

基本数据类型：

整形(int)

#整型就是任意大小的整数值，包括正数负数0
a=0
b=-1
c=2
print(f'{type(a)}{a=}')
print(f'{type(b)}{b=}')
print(f'{type(c)}{c=}')

#可进行数学运算
print(f'{a+b=}, {a-b=}, {a*c=}, {b/c=}')

#运行输出
'''
<class 'int'>a=0
<class 'int'>b=-1
<class 'int'>c=2
a+b=-1, a-b=1, a*c=0, b/c=-0.5
'''

浮点型(float)

# 创建浮点数
圆周率 = 3.14159

# 计算圆的面积
半径 = 5
面积 = 圆周率 * (半径**2)
print(面积)  # 输出：78.53975

字符串（str）

字符串是不可变序列，包含一系列字符。可以使用单引号 ' 或双引号 " 来创建。 特性：字符串方法丰富，如切片、连接、替换、查找、格式化输出等

# 创建字符串，由单引号、双引号、三引号创建字符串（三引号特殊之处：自动包含换行符之类的换行符）
a='123'
b="234"
c="""456abcdef"""
d='''567
890
'''
print(d)
# 输出：
567
890

#切片
print (c[0:-1]) # 输出第一个到倒数第二个的所有字符 456abcde
print (c[2:5])  # 输出从第三个开始到第五个的字符 6ab
print (c[2:])   # 输出从第三个开始的后的所有字符 6abcdef

#运算符连接，复制连接
print (a + "TEST") # 连接字符串 123TEST
print (c* 2)    # 输出字符串两次，也可以写成 print (2 * c) 456abcdef456abcdef

#替换，基本用法：将所有出现的old子串替换为new子串
string = "Hello, Hello, World!"
new_string = string.replace("Hello", "Hi")
print(new_string)  # 输出："Hi, Hi, World!"
# 也可以指定替换的次数
new_string = string.replace("Hello", "Hi", 1)
print(new_string) # 输出："Hi, Hello, World!"

#查找
string1="hi,123456123456"
print(string1.find("123")) #输出：3  输出的是字符串中第一个出现的位置
print(string1.index("456")) #输出：6 输出的是字符串中第一个出现的位置
print(string1.rfind("123")) #输出：9  输出的是字符串中最后一个出现的位置
print(string1.rindex("456")) #输出：12 输出的是字符串中最后一个出现的位置
print(string1.count("123")) #输出：2 输出的是字符串中出现的次数

# 使用f-string格式化输出
name='bob'
age = 25
年龄介绍 = f"{name} is {age} years old."
print(年龄介绍)  # 输出：bob is 25 years old.

f-string是3.6版本及更高版本中引入的一种新的字符串格式化方式，如有小伙伴感兴趣可留评论，后续会单独更新一篇关于f-string的快速入门使用方法，相对传统的%占位符及.format()方法格式输出，f-string更便捷明了，直观易懂

布尔型（bool）

布尔值是一种基本的数据类型，它主要用于表示真（True）或假（False）的逻辑状态。
布尔值是编程中的关键概念，用于条件判断、逻辑运算和控制流程。

任何表达式都可以被计算为一个布尔值，基于其结果是否为空、零或者真假。例如：
空容器（如空列表、元组、集合、字典）会被评估为False。
非空字符串、非零数字以及非空容器会被评估为True。
特殊值None也被视为False。

#可以使用内置函数bool()将其他类型强制转换为布尔值，例如：
bool(0)  # 返回 False
bool('')  # 返回 False
bool([])  # 返回 False
bool({})  # 返回 False
bool(None)  # 返回 False

bool(1)  # 返回 True
bool('string')  # 返回 True
bool([1, 2, 3])  # 返回 True
bool({'key': 'value'})  # 返回 True

NoneType（None）

在Python编程中，None 作为 NoneType 的实例，是一种重要的标识符，用来指示一个变量没有指向具体对象或者函数没有返回有意义的结果。

Python 中的 None 类型只有唯一的实例，即 None 这个常量。

# 创建None对象
空值 = None

# 检查变量是否为None
if 空值 is None:
    print("该变量没有赋值")

None 的引入是为了提供一种明确表达“没有值”或“缺失值”的方式，与0、空字符串、空列表等具有特定意义的其他空值区分开来。None 不支持任何方法调用或运算，尝试对 None 进行任何操作通常会导致 TypeError 异常。

• 在函数定义中，如果没有显式地返回任何值，函数将默认返回 None。
• 变量可以被赋值为 None 来表示该变量目前未指向任何对象或不包含有效数据。
• 数据结构如字典、列表等在查询不存在的键或索引时也可能返回 None。
• 在条件语句和逻辑判断中，None 被视为假（False），因此在布尔上下文中相当于 False。

高级/复合数据类型：

列表（list）

可变有序集合，元素可以是任何类型，通过索引访问。 特性：列表的方法很多，包括添加、删除、排序、反转、切片等，展示一些常用的方法：

#列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）
#列表是写在方括号 [] 之间、用逗号(英文输入法下的逗号,)分隔开的元素列表。
list1=[1,2,'abc',[567,'哈哈']] #创建列表，含数字、字符串、列表
list2=[] #也可以创建空列表

#和字符串一样，列表同样可以被索引和截取，索引值以 0 为开始值，-1 为从末尾的开始位置。
#列表被截取后返回一个包含所需元素的新列表。截取语法格式：变量[头下标:尾下标]
print(list1[2:4])  #从第三个开始后的所有元素，输出['abc', [567, '哈哈']]

#添加
list3=[1,2,3]
list3.append(100) #添加100到列表末尾，输出[1, 2, 3, 100]
list3.insert(1,'hello') #在索引为1的位置插入'hello'，输出[1, 'hello', 2, 3, 100]
list3.extend(['g','hi']) #将列表1和字符串'hi'添加到列表3中，
#注意extend只能以列表形式添加多个元素,输出[1, 'hello', 2, 3, 100, 'g', 'hi']

#删除
list4=[1,2,'c',4,5,6,7,8,9,10]
list4.pop()#删除末尾元素 10，输出[1, 2, 'c', 4, 5, 6, 7, 8, 9]
X=list4.pop(2)#删除并返回指定位置索引为2的元素 'c'，把指定元素赋值给X
print(X,list4)#输出c [1, 2, 4, 5, 6, 7, 8, 9]

list4_1=['A','B','C','D','E','F']
c=list4_1.remove('A') #c=None，它根据值移除列表中的第一个匹配项，并不返回被移除的值
print(c,list4_1) #输出None ['B', 'C', 'D', 'E', 'F']

#排序
list5=[1,5,4,2,3,6]
list5.sort()#排序，输出[1, 2, 3, 4, 5, 6]

#反转
list6=['A',2,'C',4,'B',6]
list6.reverse()#反转，输出[6, 'B', 4, 'C', 2, 'A'] 

#切片
list7 = ['abcd', 786, 2.2, 'aaa', 1.2]
new_list8 = [123, 'aaa']
print(list7)  # 输出完整列表 ['abcd', 786, 2.2, 'aaa', 1.2]
print(list7[0])  # 输出列表索引的元素 0为第一个 abcd
print(list7[1:3])  # 从第二个开始输出到第三个元素 [786, 2.2]
print(list7[2:])  # 输出从第三个元素开始的所有元素 [2.2, 'aaa', 1.2]
print(new_list8 * 2)  # 输出两次列表 [123, 'aaa', 123, 'aaa']
print(list7 + new_list8)  # 连接列表 ['abcd', 786, 2.2, 'aaa', 1.2, 123, 'aaa']

# 对于步长为负数的切片，可以从后向前选取元素
print(list7[-2:])  # 输出：['aaa', 1.2]
print(list7[::-1])  # 输出：[1.2, 'aaa', 2.2, 786, 'abcd'] 相当于倒序
# 使用步长进行切片，例如每两个元素取一个
print(list7[::2])  # 输出：['abcd', 2.2, 1.2]
# 切片也可以用于创建新列表时的复制操作
new_list = new_list8[:]  # 输出：[123, 'aaa']
print(new_list)

元组（tuple）

不可变有序集合，用法与列表类似，但创建后不能修改内容。 特性：在内存效率上通常优于列表，适合存储静态数据结构。

# 元组（元组）与列表类似，不同之处在于元组的元素不能修改。
# 元组写在小括号 () 里，元素之间用逗号隔开。
# 元组中的元素类型也可以不相同：
元组 = ('abcd', 786, 2.2, 'aaa', 1.2)
新元组 = ('啊', '噢')
print(元组)  # 输出完整元组 ('abcd', 786, 2.2, 'aaa', 1.2)
print(元组[0])  # 输出元组的第一个元素 abcd
print(元组[1:3])  # 输出从第二个元素开始到第三个元素(786, 2.2)
print(元组[2:])  # 输出从第三个元素开始的所有元素(2.2, 'aaa', 1.2)
print(新元组 * 2)  # 输出两次新元组('啊', '噢', '啊', '噢')
print(元组 + 新元组)  # 连接元组和新元组('abcd', 786, 2.2, 'aaa', 1.2, '啊', '噢')

空元组 = ()    # 空元组
一个元素元组 = (20,) # 一个元素，需要在元素后添加逗号
#如果没有添加逗号会出现以下情况
tup1=(1)
print(tup1,type(tup1))#输出 1 <class 'int'>

• 与字符串一样，元组的元素不能修改。
• 元组也可以被索引和切片，方法一样。
• 注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 元组也可以使用+操作符进行拼接。

比较一下字符串和元组的特性，可以把字符串看作一种特殊的元组。虽然不能修改已有元组，但可创建包含原元组的新元组

tup1=(1,2,3)
new_tup=tup1+('a','b') #输出(1, 2, 3, 'a', 'b')

元组是不可变的，但如果元组中嵌套了列表，那么虽然不能直接修改元组本身（例如添加或删除元素），但可以修改其内部的列表内容。案例：

tup2=(1,2,['a','b','c'])
tup2[2].append(3) #输出(1, 2, ['a', 'b', 'c', 3])

字典（dict）

键值对集合，无序且键必须唯一，值可以是任意类型。 进阶特性：字典方法用于插入、更新、删除键值对。在Python 3.7及更高版本中，字典有序性成为了语言规范的一部分，即字典现在被视为有序集合。下面展示字典的基本操作：

# 创建一个字典
dict1 = {"name": "张三", "age": 18, "sex": "男"}
# 创建空字典
dict2 = {}
# 增加数据 
# 1、字典["key"]=value  添加单个k-v
dict1["name1"] = "李四"
# 现在dict1为{"name":"张三","age":18,"sex":"男","name1":"李四"}

# 2、字典.update({'key':value,"key":value})  添加多个k-v，也可以合并字典
dict2.update({"name": "阿Q", "age": 18, "sex": "女"})
# 现在dict2为{"name":"阿Q","age":18,"sex":"女"}
dict3 = {}
dict3.update(dict1)
# x现在dict3为{'name': '张三', 'age': 18, 'sex': '男'}

# 3、字典.setdefault("key",value) #如果key存在，什么都不做，如果key不存在，添加一个k-v
dict1.setdefault("name", "王五")  # dict1中已存在"name"，所以不会有变化
print(dict1)  # 会发现dict1还是{"name":"王五","age":18,"sex":"男","name1":"李四"}
dict3 = {}
dict3.setdefault("name", "赵六")  # dict3中不存在"name"，所以会添加一个k-v
print(dict3)  # dict3为{"name":"赵六"}
"""我理解为setdefault()方法会保护原有k-v"""

# --移除数据
# 1、字典.pop('key')移除指定的key-value
dict4 = {"name": "阿三", "age": 18, "sex": "男", "name2": "细佬"}
a = dict4.pop("name")  # 删除指定的k-v并返回对应key的value，如果key不存在会报错
print(a)  # 输出 ”阿三“
a = dict4.pop("name100", "字典中不存在该key")  # 当key不存在时，返回自定义的值
# 2、字典.popitem()移除最后一个k-v
item = dict4.popitem()  # 删除最后一个k-v并以元组类型返回对应k-v
print(item, type(item))  # 输出 ('age', 18) <class 'tuple'>
# 3、字典.clear() 全部移除
dict4.clear()  # 清空了dict4，输出空字典{}

再来看看字典怎么获取值

dict5={"name":"阿三","age":18,"sex":"男"}
# 1、字典["key"] 根据key 取值  如果key不存在 会报错
print(dict5["name"]) #输出 “阿三”
# print(dict5["name100"]) #报错  KeyError: 'name100'
# 2、字典.get("key","可自定义返回值") 根据key取值，如果key不存在，返回默认值
print(dict5.get("name")) #输出 “阿三”
print(dict5.get("name100","字典中不存在该key")) #输出 “字典中不存在该key”,
#如果没自定义则输出None

# 3、list(字典.keys())返回所有的key
print(list(dict5.keys()))
# 4、list[字典.values()]返回所有的value
print(list(dict5.values()))
# 5、list[字典.items()]  返回所有的k-v
print(list(dict5.items()))

集合（set）

无序不重复元素集，成员自动去重，支持集合间的数学运算，如并集、交集、差集。 平时集合的基本用法就是用来去重。

# 创建集合
s={1,2,3,4,5,5,5,5} #直接用大括号{}创建,集合会把重复的元素去掉
l1=[3,4,5,6,7,6,5,7,7,7]
s1=set(l1) #可以将其他可迭代对象创建成集合
str1='1233344455566699977789' #可以将其他可迭代对象创建成集合
s2=set(str1)
print(s,s1,s2) #{1, 2, 3, 4, 5} {3, 4, 5, 6, 7} {'4', '2', '5', '7', '6', '3', '9', '1', '8'}

#修改数据
#集合.add(1)加入新成员
s3={3,4}
s3.add(1)
print(s3) #{1, 3, 4}
#集合.remove(1)移除旧成员
s3.remove(4)
print(s3) #{1, 3}

并集、交集、差集以及对称差集(分别存在两个集合，但不同时存在两个集合的所有元素)

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
# a 和 b 的差集
print(a - b)  # {1, 2}
print(b - a)  # {5, 6}
print(a.difference(b))  # {1, 2}
print(b.difference(a))  # {5, 6}

# a 和 b 的并集
print(a | b)#{1, 2, 3, 4, 5, 6}
print(a.union(b))#{1, 2, 3, 4, 5, 6}

# a 和 b 的交集
print(a & b)#{3, 4}
print(a.intersection(b))#{3, 4}

# a 和 b 中不同时存在的元素
print(a ^ b)#{1, 2, 5, 6}
print(a.symmetric_difference(b))#{1, 2, 5, 6})

4、控制结构

条件语句

Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块

通过下图简单了解条件语句的执行过程

一般形式如下：

#条件控制
if 条件1:
    执行1
elif 条件2:
    执行2
else: 
    执行3  #条件1和条件2都不符合

如果 "条件1" 为 True 将执行 "执行1" 块语句
如果 "条件1" 为False，将判断 "条件2"
如果"条件2" 为 True 将执行 "执行2" 块语句
如果 "条件2" 为False，将执行"执行3"块语句

简单实例：

a=3
if a>4:
    print("a大于4")
elif a==4:
    print("a等于4")
else:
    print("a小于4") #不满足if条件，执行else语句

#最终输出  a小于4

#if嵌套
a=4
if a>4:
    print("a大于4")
else:
    if a==4:
        print("a等于4")
    else:
        print("a小于4")
#最终输出  a等于4

#match...case
a=4
match a:
    case 1:
        print('a等于1')
    case 2:
        print('a等于2')
    case 3:
        print('a等于3')
    case 4:
        print('a等于4')
    case 5:
        print('a等于5')
#最终输出  a等于4

循环结构

Python 中的循环语句有 for 和 while。

for循环语句

for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串，for循环的一般格式如下：

for item in iterable:
    # 循环主体
else:
    # 循环结束后执行的代码

简单实例：

#for 循环遍历序列或迭代器：
for item in range(5): #range(5)生成一个序列0,1,2,3,4
    print(item)
else:
    print("循环完后执行else语句")


#break 的应用
for i in range(10): #range(10)生成序列0~9
    if i == 5:#如果i等于5，就执行break语句，终止循环
        break
    print(i)
0
1
2
3
4

while循环语句

while循环，只要满足条件就循环，一般格式如下：

while 判断条件：
    执行语句……

简单实例

# 计算1~10的和
a = 1
sum1 = 0
while a <= 10:
    sum1 += a
    a += 1
print(sum1) # 55

# 使用break
n = 5
while n > 0:
    n -= 1
    if n == 2:
        break  # 当n==2时，跳出循环
    print(n)
print('循环结束')
# 输出：4 3 循环结束。

# 使用continue
n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue  # 当n==2时，跳过本次循环
    print(n)
print('循环结束')
# 输出：4 3 1 0 循环结束。

5、函数定义

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。我们已经知道Python提供了许多内建函数，比如print()。但我们也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数，以下是简单的规则：

1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
2. 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4. 函数内容以冒号 : 起始，并且缩进。
5. return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

简单实例：

#定义一个求和的函数
def sum(a, b):
    print("该函数返回结果为a+b的和")
    return a + b
print(sum(1, 2))#输出 该函数返回结果为a+b的和 3

#定义一个比较a，b大小的函数
def max(a, b):
    if a > b:
        return a
    else:
        return b
print(max(3, 4)) #调用函数max，比较3和4大小，返回4

6、输入/输出

输入：使用 input() 函数获取用户输入。输出：使用 print() 函数打印内容到控制台。

name = input("请输入您的名字: ")

print(name)

#运行结果
'''
请输入您的名字: a
a
'''

还有格式化输出f-string，可以在后续深入更新一篇

7、异常处理

代码如下：

try:
    # 可能出现异常的代码块
except ExceptionType:
    # 处理特定类型的异常
except:
    # 处理所有其他未指定的异常
finally:
    # 不论是否发生异常都会执行的代码块

8、模块导入

import 库名 引入 模块；这是引入某一模块的方法：

import module_name  # 导入整个模块
from module_name import function_name  # 导入模块中的特定功能

pass：更新一篇长文确实挺耗时，以后再就小模块深入剖析学习