python教程1——python基础语法_python如何print向左一位-CSDN博客

本文链接：https://blog.csdn.net/CH2102/article/details/136529883

python 的基本语法

1 程序基本结构 2 变量与动态数据类型 3 基本数据结构（数字、集合、字符串、列表、元组和字典）

基本程序结构

1 缩进表示代码块 2 代码注释 3 语句续行 4 语句分隔 5 关键字大小写

代码注释 有：1 单行注释 # 后开始注释内容 2 三个单引号或双引号

语句续行 有：1 \ + enter （\后面不能有任何符号，包括空格和注释）

2 使用括号，如 (), [], {} 括号内容可分多行书写，括号中的空白和换行符都会被忽略

语句分隔 分号分隔语句，从而将多行语句写在同一行

基本输出

输出多个对象 print(123,‘abc’,‘45’)

输出指定分隔符 print(123,‘abc’,‘45’,spe=‘#’) #指定用“#”作为输出分隔符

输出指定结尾 print(‘price’,end=‘=’);print(100)

输出到文件

file_1 = open('data.txt','w')  # 打开文件
print(123,'abc',45,'book',file=file_1) #用file参数指定输出到文件
file_1.close()
print(open('data.txt').read())

数据类型

数字

二进制 0b或0B开头八进制 0o或0O开头十六进制 0x或0X开头

内置函数 bin() 求二进制数 oct() 求八进制数 hex 求十六进制数

int函数 将一个字符串按指定进制转换为整数例 int(‘111’,2) 按二进制转换

查看函数数据类型 type(123)

复数常量 complex(实部，虚部) complex(2,3) = (2+3j)

运算

1 计算的优先级 2 计算中的默认数据类型转换 3 真除法和floor除法 4 求余数 5 位运算

重点提及3和5

真除法和floor除法 4/2 = 2.0 为真除法 "//"称为floor除法 (x//y)结果为不大于 (x/y)的最大整数

x = 4
y = 2
true_division = x / y # 真除法
floor_division = x // y # floor除法

print(“真除法结果:”, true_division) # 输出 2.0
print(“floor除法结果:”, floor_division) # 输出 2

位运算 ~, &, ^, <<, >> 均为位运算符

位运算

在Python中，位运算是对整数的二进制位进行操作的一种运算方式。以下是常见的位运算符及其功能：

~（按位取反）：对一个数的每个二进制位取反，0 变为 1，1 变为 0。
&（按位与）：对两个数的每个对应位执行与操作，只有两个位都为 1 时结果才为 1。
|（按位或）：对两个数的每个对应位执行或操作，只要两个位中有一个为 1 结果就为 1。
^（按位异或）：对两个数的每个对应位执行异或操作，相同为0，不同为1。
<<（左移）：将一个数的二进制位向左移动指定的位数，右侧空出的位用0填充。
>>（右移）：将一个数的二进制位向右移动指定的位数，左侧空出的位根据原来的符号位填充。

a = 5
b = 3

bitwise_not = ~a
bitwise_and = a & b
bitwise_xor = a ^ b
left_shift = a << 1
right_shift = a >> 1

print("按位取反:", bitwise_not)  # 输出 -6
print("按位与:", bitwise_and)  # 输出 1
print("按位异或:", bitwise_xor)  # 输出 6
print("左移一位:", left_shift)  # 输出 10
print("右移一位:", right_shift)  # 输出 2

数学函数

abs(x)：返回一个数的绝对值。
bin(x)：将一个整数转换为二进制字符串。
chr(x)：返回 Unicode 码位为 x 的字符。
ord(x)：返回字符 x 的 Unicode 码位。
divmod(x, y)：返回 x 除以 y 的商和余数，以元组形式返回。
eval(expr)：将字符串表达式作为 Python 代码执行并返回结果。
max(iterable)：返回可迭代对象中的最大值。
min(iterable)：返回可迭代对象中的最小值。
pow(x, y)：返回 x 的 y 次幂。
round(x, n)：将一个数 x 四舍五入到 n 位小数。
sum(iterable)：返回可迭代对象中所有元素的和。

math 模块常量和函数

在 Python 中，math 模块提供了许多数学常量和函数，可以进行更复杂的数学运算。以下是一些常用的数学常量和函数：

pi：圆周率，约等于 3.14159。
e：自然对数的底，约等于 2.71828。
inf：正无穷大。
ceil(x)：返回大于或等于 x 的最小整数。
fabs(x)：返回 x 的绝对值。
factorial(x)：返回 x 的阶乘。
floor(x)：返回小于或等于 x 的最大整数。
fmod(x, y)：返回 x 除以 y 的余数。
fsum(iterable)：返回可迭代对象中所有元素的精确浮点和。
gcd(a, b)：返回 a 和 b 的最大公约数。
trunc(x)：返回 x 的整数部分。
exp(x)：返回 e 的 x 次幂。
expm1(x)：返回 e 的 x 次幂减去 1。

这些常量和函数可以帮助我们在数学计算中处理更复杂的情况。

示例程序和注释

import math

# 计算圆的周长
def circle_circumference(radius):
    return 2 * math.pi * radius

# 计算阶乘和
def factorial_sum(n):
    fact_sum = sum(math.factorial(i) for i in range(1, n+1))
    return fact_sum

# 输出圆周长和阶乘和
radius = 5
n = 4
print(f"圆的周长：{circle_circumference(radius)}")
print(f"1到{n}的阶乘和：{factorial_sum(n)}")

这个示例程序演示了如何使用 math 模块中的常量和函数来计算圆的周长和一定范围内阶乘的和。通过这些函数，我们可以更方便地进行数学运算。

变量与动态数据类型

变量与对象

在 Python 中，变量是用来存储数据的标识符，而对象则是存储在内存中的实际数据。变量通过赋值来引用对象，一个变量可以引用不同类型的对象。

对象的垃圾回收

Python 使用自动内存管理机制来管理对象的生命周期。当一个对象不再被任何变量引用时，Python 的垃圾回收机制会自动将其回收，释放内存空间。

变量命名规则

在 Python 中，变量名必须遵循一定的命名规则：

变量名只能包含字母、数字和下划线。
变量名不能以数字开头。
变量名区分大小写。
变量名应具有描述性，能清晰表达变量的用途。

赋值语句

赋值语句用来将一个对象赋给一个变量。在 Python 中，赋值是将变量指向对象的过程，而不是将值复制给变量。

示例：

x = 10

在这个例子中，x 是变量，10 是对象，赋值操作将 x 指向整数对象 10。

变量的共享引用

在 Python 中，多个变量可以引用同一个对象，这种情况被称为共享引用。当一个对象被多个变量引用时，对这个对象的修改会影响所有引用它的变量。

示例：

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # 输出 [1, 2, 3, 4]

在这个例子中，a 和 b 都引用了同一个列表对象，因此对 b 的修改也会影响到 a。

列表

列表的基本特点

列表是 Python 中一种常用的数据结构，用于存储多个元素的有序集合。
列表中的元素可以是任意数据类型，包括数字、字符串、列表等。
列表是可变的，可以动态添加、删除和修改元素。

列表的基本操作

创建列表：

my_list = [1, 2, 3, 4, 5]

访问元素：

print(my_list[0])  # 输出第一个元素

切片操作：

print(my_list[1:3])  # 输出索引 1 到 2 的元素

添加元素：

my_list.append(6)  # 在末尾添加元素

删除元素：

del my_list[2]  # 删除索引为 2 的元素

常用列表方法

append(element): 在列表末尾添加一个元素。
insert(index, element): 在指定位置插入一个元素。
pop(index): 移除并返回指定位置的元素。
remove(element): 移除列表中第一个匹配的元素。
index(element): 返回指定元素的索引。
count(element): 返回指定元素在列表中出现的次数。
sort(): 对列表进行排序。
reverse(): 反转列表中的元素顺序。

这些方法可以帮助你对列表进行各种操作，从添加和删除元素到排序和反转列表。列表是 Python 中非常灵活和常用的数据结构，能够方便地处理多个元素的集合。

元组

元组的特点

元组是 Python 中的另一种数据结构，类似于列表，但元组是不可变的，一旦创建就不能修改。
元组使用圆括号 () 来表示，元素之间用逗号 , 分隔。
元组可以包含不同类型的元素，类似于列表。

元组的基本操作

创建元组：

my_tuple = (1, 2, 3, 4, 5)

访问元素：

print(my_tuple[0])  # 输出第一个元素

切片操作：

print(my_tuple[1:3])  # 输出索引 1 到 2 的元素

元组的方法

由于元组是不可变的，因此元组的方法相对较少，常用的方法包括：

count(element): 返回元组中指定元素出现的次数。
index(element): 返回元组中指定元素的索引。

由于元组的不可变性，你无法像列表那样对元组进行添加、删除或修改元素的操作。元组通常用于存储不可变的数据集合，如函数返回多个值时常用元组来返回。

字典

字典的特点

字典是 Python 中的一种数据结构，用于存储键值对。
字典使用大括号 {} 来表示，每个键值对之间用冒号 : 分隔，键值对之间用逗号 , 分隔。
字典中的键必须是唯一的，但值可以重复。

字典的基本操作

创建字典：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

访问元素：

print(my_dict['name'])  # 输出键为 'name' 的值

修改元素：

my_dict['age'] = 31  # 修改键为 'age' 的值

添加元素：

my_dict['gender'] = 'Female'  # 添加新的键值对

删除元素：

del my_dict['city']  # 删除键为 'city' 的键值对

字典的基本用法

遍历字典：

for key, value in my_dict.items():
    print(key, value)

检查键是否存在：

if 'age' in my_dict:
    print('Age is present in the dictionary')

字典视图

字典视图是字典的动态视图，分为三种类型：

keys() 方法返回字典中所有的键。
values() 方法返回字典中所有的值。
items() 方法返回字典中所有的键值对。

字典视图可以用于遍历字典中的键、值或键值对，具有动态性，即当字典发生变化时，视图也会相应改变。

文件

打开和关闭文件

在 Python 中，要操作文件，通常需要执行以下步骤：

打开文件：使用 open() 函数来打开一个文件，可以指定打开文件的模式（读取、写入、追加等）。
读写文件：对打开的文件对象执行读取或写入操作。
关闭文件：使用 close() 方法关闭文件，释放系统资源。

file = open('example.txt', 'r')  # 以只读模式打开文件
# 读取或写入操作
file.close()  # 关闭文件

读写文本文件

读取文本文件：

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

写入文本文件：

with open('output.txt', 'w') as file:
    file.write('Hello, World!')

读写二进制文件

读取二进制文件：

with open('binary_file.bin', 'rb') as file:
    data = file.read()
    print(data)

写入二进制文件：

with open('output.bin', 'wb') as file:
    file.write(b'\x48\x65\x6c\x6c\x6f')  # 写入字节数据

用文件存储 Python 对象

Python 中可以使用 pickle 模块来实现对象的序列化和反序列化，将对象存储到文件或从文件中加载对象。

存储对象到文件：

import pickle

data = {'name': 'Alice', 'age': 30}
with open('data.pickle', 'wb') as file:
    pickle.dump(data, file)

从文件加载对象：

import pickle

with open('data.pickle', 'rb') as file:
    loaded_data = pickle.load(file)
    print(loaded_data)

使用 pickle 可以方便地将 Python 对象序列化为字节流并存储到文件中，以及从文件中加载对象。

程序流控制

if 分支语句

if 语句基本结构

if 分支语句是编程中常用的控制流结构，用于根据条件选择不同的执行路径。在 Python 中，if 语句的基本结构如下：

if condition:
    # 如果条件为真，执行这里的代码块

真值测试

在 Python 中，条件表达式的真值测试是根据条件表达式的值来确定其真假。Python 中的一些对象会被视为假，如 False、None、0、空字符串 ''、空列表 []、空字典 {}、空集合 set() 等，其他对象都被视为真。

示例代码：

x = 10
if x:
    print("x 是真值")
else:
    print("x 是假值")

if……else三元表达法

Python 中的三元表达式是一种简洁的写法，用于根据条件选择不同的值。它的基本结构如下：

value_if_true if condition else value_if_false

这种写法可以在一行代码中根据条件返回不同的值，提高代码的简洁性和可读性。

示例代码：

x = 10
result = "x 是正数" if x > 0 else "x 是负数或零"
print(result)

使用三元表达式可以在一些简单的情况下替代传统的 if...else 结构，使代码更加简洁。

for 循环

for 循环基本格式

for 循环是一种常见的循环结构，用于遍历序列中的元素或执行一定次数的循环操作。在 Python 中，for 循环的基本格式如下：

for element in iterable:
    # 对每个元素执行操作

其中，element 是迭代变量，iterable 是可迭代对象，如列表、元组、字符串等。

多个变量迭代

在 Python 的 for 循环中，可以同时迭代多个变量，这样可以方便地处理多个序列的对应元素。示例代码如下：

fruits = ['apple', 'banana', 'cherry']
colors = ['red', 'yellow', 'purple']

for fruit, color in zip(fruits, colors):
    print(f"The {fruit} is {color}")

break 和 continue

在循环中，break 和 continue 是常用的控制语句，用于改变循环的执行流程。break 用于提前结束循环，而 continue 则用于跳过当前循环中的剩余代码，直接进入下一次循环。

示例代码：

for i in range(5):
    if i == 2:
        break  # 当 i 等于 2 时提前结束循环
    print(i)

嵌套使用 for 循环

在 Python 中，可以嵌套使用 for 循环，用于处理多维数据结构或多重循环场景。嵌套循环的结构如下：

for i in range(3):
    for j in range(2):
        print(f"({i}, {j})")

这种嵌套循环的结构可以处理二维数组、矩阵等复杂数据结构，或者在需要多重循环的情况下使用。

while 循环

while 循环基本结构

while 循环是另一种常见的循环结构，它会在条件为真的情况下重复执行一段代码块。while 循环的基本结构如下：

while condition:
    # 在条件为真时执行的代码

在每次循环迭代开始时，首先会检查 condition 是否为真。只要条件为真，循环就会继续执行；一旦条件为假，循环就会结束。

示例代码：

count = 0
while count < 5:
    print(count)
    count += 1

嵌套使用 while 循环

和 for 循环一样，while 循环也可以嵌套使用。这种嵌套结构可以用于处理复杂的逻辑或需要多层循环的情况。

示例代码：

row = 0
while row < 3:
    col = 0
    while col < 2:
        print(f"({row}, {col})")
        col += 1
    row += 1

在上面的示例中，外部 while 循环控制行数，内部 while 循环控制列数，这样可以实现对二维数据结构的遍历或处理。

迭代和列表解析

迭代

迭代是一种重要的编程概念，用于遍历数据集中的元素。在 Python 中，我们可以使用循环结构（如 for 循环）来进行迭代操作。通过迭代，我们可以逐个访问数据集中的元素，执行特定操作。

示例代码：

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

列表解析

列表解析是一种简洁而强大的方式来创建列表。它允许我们在一行代码中根据现有的列表快速生成新的列表。列表解析通常比传统的循环方法更简洁和高效。

示例代码：

numbers = [1, 2, 3, 4, 5]
squared_numbers = [x**2 for x in numbers]
print(squared_numbers)

zip, map, filter

zip：将多个可迭代对象打包成元组的列表。
示例代码：

fruits = ["apple", "banana", "cherry"]
colors = ["red", "yellow", "purple"]
fruit_colors = list(zip(fruits, colors))
print(fruit_colors)

map：对可迭代对象中的每个元素应用函数。
示例代码：

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers)

filter：根据函数的返回值过滤可迭代对象中的元素。
示例代码：

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)

这些函数提供了一种便捷的方法来处理数据集，使代码更简洁和易读。