python基本语法

1、行与缩进

python用缩进标识代码块，而不用{}，每个缩进级别通常使用 4 个空格，尽量不要混用空格和Tab。
可以在同一行中使用多条语句，语句之间使用分号;
一般来说在一行内写完一条语句，但如果语句较长可以使用\实现多行语句

total = item_one + \
        item_two + \
        item_three

2、注释

# 单行注释

'''
多行注释
多行注释
'''

"""
多行注释
多行注释
"""

多行注释不能嵌套在多行注释中，也就是多行注释中只能有单行注释。

3、赋值

使用=赋值，和java不同的是python不需要声明变量类型。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

# 单个变量赋值
a=1
# 多个变量赋值
a = b = c = 1
a, b, c = 1, 2, "test"

4、基本数据类型

六个标准数据类型：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）；
此外常见的还有布尔类型bool。

String

Python中单引号’和双引号"使用完全相同，字符串使用单引号或双引号都可以。

str1='test'
str2="test2"

特殊字符用\转义，使用 r 可以让反斜杠不发生转义。

>>> print('test\ntt')
test
tt
>>> print(r'test\ntt')
test\ntt
>>>

字符串的截取：
字符串的索引可以从左往右（0开始），也可以从右往左（-1开始）

#!/usr/bin/python3

str = 'helloworld'  # 定义一个字符串变量

print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[-2])       # 打印字符串的倒数第二个字符
print(str[2:5])      # 打印字符串第三到第五个字符（不包含索引为 5 的字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

注意Python 字符串不能被改变。向一个索引位置赋值，比如 str[0] = ‘t’ 会导致错误。

使用三引号(‘’’ 或 “”")可以指定一个多行字符串。

Number

Python3 支持 int、float、bool、complex（复数）

常规的加减乘不再赘述，做除法时，/返回浮点数，//返回整数（且是往小的方向取整），以及可以使用**代表乘方。

>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

bool

python中的布尔类型是True和False，可以和1和0互转，在用布尔类型和其他类型进行比较时，True等价为1，False等价为0.也可以和其他类型互相转换，示例：

# 布尔类型的值和类型
a = True
b = False
print(type(a))  # 
print(type(b))  # 

# 布尔类型的整数表现
print(int(True))   # 1
print(int(False))  # 0

# 使用 bool() 函数进行转换
print(bool(0))         # False
print(bool(42))        # True
print(bool(''))        # False
print(bool('Python'))  # True
print(bool([]))        # False
print(bool([1, 2, 3])) # True

# 布尔逻辑运算
print(True and False)  # False
print(True or False)   # True
print(not True)        # False

逻辑运算符：and or not

List（列表）

List中的元素类型可以不同，截取方式和String一致：testList[0:-1]，也可以通过+拼接，但List中的元素可以被改变。

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 [] 
>>> a
[9, 2, 6]

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ['Hi!'] * 4
['Hi!', 'Hi!', 'Hi!', 'Hi!']

>>> print('a' in ['a','b','c'])
True

List还可以接受第三个参数作为步长：testList[0:-1:2] 或者如果想直接从遍历到末尾的话就testList[0::2] ，当步长为负数时代表逆向，所以testList[-1::-1]的含义就是翻转列表，前两个参数表示从末尾到第一个元素，-1再代表逆向移动。不过如果仅仅是翻转的话直接用reverse()就可以

testList=['a','b','c','d','e','f']
testList.reverse()
print(testList)
# 注意.reverse()并没有返回，所以如果直接print(testList.reverse())，打印出来的会是None

python中list的函数：

函数	作用
len(list)	获取列表长度
min(list)	获取列表中最小的元素
max(list)	获取列表中最大的元素
list(seq)	将元组转为列表

List的方法：

方法	用处
append(obj)	添加元素
insert(index,obj)	插入元素
remove(obj)	移除元素
pop()	弹出末尾元素
index(obj)	获取元素下标
count(obj)	元素出现次数
sort(key=None,reverse=False)	排序
clear()	清空
copy()	复制
reverse()	翻转
extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

嵌套列表

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

列表间的比较可以引入operator模块

Tuple（元组）

用()表示，和List类似，一个元组中可以有不同类型的元素，也可以用+拼接，但元组中的元素不可以被改变(但可以重新赋值元组)。

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
print(tuple[1:4])

如果想创建只有一个元素的元组，需要在元素后面添加一个逗号，如果没有逗号括号会被认为是数学运算中的括号。

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

Set（集合）

用{}表示，Set中的元素不重复，且可以进行交集、并集、差集等运算。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

testset = { 'abcd', 786 , 2.23, 'runoob', 70.2 }
print(tuple[1:4])

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)         # {'a', 'r', 'b', 'c', 'd'}

print(a - b)     # a 和 b 的差集

print(a | b)     # a 和 b 的并集

print(a & b)     # a 和 b 的交集

print(a ^ b)     # a 和 b 中不同时存在的元素（对称差集）

Set的方法：

方法	作用
add(x)	添加元素，若元素已存在则不进行操作
update(x)	添加元素，且参数可以为列表，字典，元组等，可以有多个参数，参数间逗号隔开
remove(x)	移除元素，若元素不存在则报错
discard(x)	移除元素，若元素不存在则报错
pop()	随机删除一个元素
result = set1.difference(set2, set3, …)	返回集合的差集，不修改原集合，返回新集合，支持多参数
set1.difference_update(set2, set3, …)	和difference的区别在于返回是None，直接移除原集合中属于其他集合的元素
result = set1.union(set2, set3, …)	返回并集
result = set1.intersection(set2, set3, …)	返回两个集合的交集
set1.intersection_update(set2, set3, …)	也是交集，但修改原集合，返回None
result = set1.symmetric_difference(set2)	返回对称差集，只支持一个参数，等价于result = set1 ^ set2
a.symmetric_difference_update(b)	对称差集操作，但直接修改原集合,等价于set1 ^= set2
set1.issubset(set2)	set1是否是set2的子集，等价于set1 <= set2
set1.issuperset(set2)	set1是否是set2的超集，等价于set1 >= set2
bool_result = set1.isdisjoint(set2)	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False

Dictionary（字典）

字典是一种映射类型（键值对），用 { } 标识，是一个无序的键(key) : 值(value) 的集合。key必须使用不可变类型，且在同一个字典中，key必须是唯一的。

tinydict = {'Name': '小明', 'Age': 7, 'Class': 'First'}  # 建字典
print ("tinydict['Name']: ", tinydict['Name'])  # 访问字典中的元素，如果使用字典里没有的键访问会报错
tinydict['Age'] = 8              # 更新 Age
tinydict['School'] = "XXschool"  # 添加信息
del tinydict['School']           # 删除元素

print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

#遍历键值对
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")
#字典推导式
squared_dict = {k: v**2 for k, v in my_dict.items()}

数据类型转换

int和float可以隐式转换，对String和int进行运算时需要显示抓换
例如转成int：int(x)，同理还有float(x)、str(x)、set(x)等等

5、语句

条件（if）

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

python3.10新增了match…case，类似于switch-case

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

mystatus=400
print(http_error(400))

case _: 类似于Java 中的default:，当其他 case 都无法匹配时匹配

循环（for、while）

for：

#!/usr/bin/python3
 
word = 'abce'
 
for letter in word:
    print(letter)

还可以使用for…else，当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

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

while:

#!/usr/bin/env python3
 
n = 100
 
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))

同样的也可以使用while…else，在while后面的语句为false时（其实也就是正常结束循环时）执行。

6、函数

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

# 举例
#!/usr/bin/python3
 
def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

7、输入输出

input()函数用于读入一行文本

#!/usr/bin/python3
str = input("请输入：");
print("你输入的内容是: ", str)

输出：

# 换行输出
print(x)
print(y)

#不换行输出
print(x, end=" ")
print(y, end=" ")

8、面向对象

用class关键字定义类，类中的方法与普通函数的区别是第一个入参必须为self，用于表示类的实例（对象）自身。它是一个指向实例的引用，使得类的方法能够访问和操作实例的属性。

class MyClass:
    def __init__(self, value):
        self.value = value

    def display_value(self):
        print(self.value)

# 创建一个类的实例
obj = MyClass(42)

# 调用实例的方法
obj.display_value() # 输出 42

__init__为类的构造函数。

python类的类支持继承，并且支持多继承，方法在子类中未找到时，从左到右查找父类中是否包含方法。

class DerivedClassName(BaseClassName):

# 多继承
class DerivedClassName2(Base1, Base2, Base3):

和java的private public关键字不同，python变量和方法的私有、公有区别由方法/变量名称决定，如果方法/变量名称为__开头则为私有，否则为公有。