1-2-python基础语法

原创 已于 2024-11-10 20:31:17 修改 · 940 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python

于 2024-11-10 20:31:02 首次发布

声明！

通过学习 泷羽sec的个人空间-泷羽sec个人主页-哔哩哔哩视频，做出的文章，如涉及侵权马上删除文章，笔记的只是方便各位师傅学习知识，以下网站只涉及学习内容，其他的都与本人无关,切莫逾越法律红线,否则后果自负.

文章为个人学习笔记。

数据类型

  1. Number（数字）：

    • 用于表示整数和浮点数。

    • 整数类型包括：int（有符号整数）。

    • 浮点数类型包括：float（双精度浮点数）和complex（复数）。

  2. String（字符串）：

    • 用于表示文本数据。

    • 可以进行制表符、换行符、切片等操作。

    • 字符串是不可变的，即一旦创建就不能被改变。

  3. bool（布尔类型）：

    • 只有两个值：True和False。

    • 常用于条件判断。

  4. List（列表）：

    • 有序的元素集合。

    • 元素可以是任何数据类型，包括其他列表。

    • 列表是可变的，可以添加、删除和修改元素。

  5. Tuple（元组）：

    • 类似于列表，但一旦创建就不能修改。

    • 元组通常用于存储不应改变的数据。

  6. Set（集合）：

    • 无序的元素集合。

    • 元素唯一，即集合中不能有重复的元素。

    • 集合是可变的，可以添加和删除元素。

  7. Dictionary（字典）：

    • 无序的键值对集合。

    • 键必须是不可变类型，如字符串、数字或元组。

    • 字典是可变的，可以添加、删除和修改键值对。

num=12346
atr="12346"
float=1.5455
list=['1',545,"小羽",54,54.5]
b=True
a=False
tuple=(1,2,3,4,5)

print(type(num))
print(type(float))
print(type(atr))
print(type(list))
print(type(b))
print(type(a))
print(type(tuple))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'list'>
<class 'bool'>
<class 'bool'>
<class 'tuple'>

数字类型

包括整数（int）、浮点数（float）、布尔类型（bool）和复数（complex）。以下是对这些数字类型的解释和补充，以及一些例子：

  1. int（整数）：

    • 用于表示没有小数部分的数字。

    • Python 3中，整数类型是无限精度的，不受固定位数限制。

    • 例子：a = 20​，type(a)​的结果是<class 'int'>​。

  2. float（浮点数）：

    • 用于表示带有小数部分的数字。

    • 浮点数的精度受限于计算机的内存和处理器。

    • 例子：b = 5.5​，type(b)​的结果是<class 'float'>​。

  3. bool（布尔类型）：

    • 只有两个值：True和False。

    • 布尔类型是整数的子类，True等价于1，False等价于0。

    • 例子：c = True​，type(c)​的结果是<class 'bool'>​。

  4. complex（复数）：

    • 用于表示复数，由实部和虚部组成。

    • 复数的一般形式是a + bj，其中a是实部，b是虚部，j是虚数单位。

    • 例子：d = 4+3j​，type(d)​的结果是<class 'complex'>​。

Python中的数字类型赋值和计算非常直观。例如：

# 整数
a = 10
print(a)  # 输出: 10

# 浮点数
b = 3.14
print(b)  # 输出: 3.14

# 布尔类型
c = True
print(c)  # 输出: True

# 复数
d = 2 + 3j
print(d)  # 输出: (2+3j)

内置的type()​函数可以用来查询变量所指的对象类型，这对于调试和类型检查非常有用。例如：

print(type(a))  # 输出: <class 'int'>
print(type(b))  # 输出: <class 'float'>
print(type(c))  # 输出: <class 'bool'>
print(type(d))  # 输出: <class 'complex'>

字符串的基本操作

  1. 字符串定义：

    • 字符串可以用单引号'​或双引号"​括起来。

    • 反斜杠\​用于转义特殊字符。

  2. 字符串切片：

    • 字符串切片使用方括号[]​，格式为变量[头下标:尾下标]​。

    • 下标从0开始，表示字符的位置。

    • 切片可以省略头下标或尾下标，省略头下标表示从头开始，省略尾下标表示直到字符串末尾。

  3. 字符串操作示例：

    • ​print(str)​：打印整个字符串。

    • ​print(str[0:-1])​：打印从第一个字符到倒数第二个字符。

    • ​print(str[0])​：打印字符串的第一个字符。

    • ​print(str[2:5])​：打印从第三个字符到第五个字符（不包括第五个字符）。

    • ​print(str[2:])​：打印从第三个字符开始到字符串末尾。

    • ​print(str * 2)​：打印字符串两次。

    • ​print(str + "TEST")​：将字符串和"TEST"拼接在一起。

    • print(str[1:2:5])

  4. 转义字符：

    • 使用反斜杠\​可以转义特殊字符，如换行符\n​、制表符\t​等。

    • 如果不想让反斜杠发生转义，可以在字符串前面添加r​，表示原始字符串。

例子：

# 定义一个字符串
str = 'SFeather'

# 打印整个字符串
print(str)  # 输出: SFeather

# 打印字符串的第一个字符
print(str[0])  # 输出: S

# 打印字符串的第二个字符到第五个字符
print(str[1:5])  # 输出: Ffee

# 打印字符串两次
print(str * 2)  # 输出: SFeatherSFeather

# 将字符串和"TEST"拼接在一起
print(str + "TEST")  # 输出: SFeatherTEST

# 尝试修改字符串的第二个字符（会导致错误）
# str[1] = '小羽'  # 这行代码会导致错误，因为字符串是不可变的

# 打印原始字符串，不转义反斜杠
print(r'SF\eather')  # 输出: SF\eather

#间隔2个
print(str[1:2:5])

SFeather
S
Feat
SFeatherSFeather
SFeatherTEST
SF\eather
F

‍

  1. 字符串连接：
    使用+​运算符连接字符串。

    name = "Alice"
greeting = "Hello, "
message = greeting + name + "!"
print(message)  # 输出: Hello, Alice!

  2. 字符串重复：
    使用*​运算符重复字符串。

    repeat_str = "abc" * 3
print(repeat_str)  # 输出: abcabcabc

  3. 字符串切片：
    使用[start:stop:step]​语法切片字符串。

    text = "Python programming is fun!"
print(text[0:6])  # 输出: Python
print(text[7:15]) # 输出: programming
print(text[16:])  # 输出: is fun!
print(text[:6])   # 输出: Python
print(text[7::2]) # 输出: pgmrn gfun

  4. 字符串索引：
    使用索引访问字符串中的单个字符。

    text = "Python"
print(text[0])  # 输出: P
print(text[-1]) # 输出: n

  5. 字符串长度：
    使用len()​函数获取字符串长度。

    text = "Python"
print(len(text))  # 输出: 6

  6. 字符串查找：
    使用in​关键字检查子字符串是否存在。

    text = "Python"
print("th" in text)  # 输出: True
print("java" in text) # 输出: False

  7. 字符串替换：
    使用replace()​方法替换子字符串。

    text = "Python is great"
new_text = text.replace("great", "awesome")
print(new_text)  # 输出: Python is awesome

  8. 字符串大小写转换：
    使用upper()​和lower()​方法转换大小写。

    text = "Python"
print(text.upper())  # 输出: PYTHON
print(text.lower())  # 输出: python

  9. 字符串分割：
    使用split()​方法按分隔符分割字符串。

    text = "Python, Java, C++"
languages = text.split(", ")
print(languages)  # 输出: ['Python', 'Java', 'C++']

  10. 字符串拼接：
    使用join()​方法将列表中的元素拼接成字符串。

    languages = ["Python", "Java", "C++"]
text = ", ".join(languages)
print(text)  # 输出: Python, Java, C++

  11. 字符串格式化：
    使用format()​方法或f-string进行字符串格式化。

    name = "Alice"
age = 30
greeting = "Hello, my name is {} and I am {} years old.".format(name, age)
print(greeting)  # 输出: Hello, my name is Alice and I am 30 years old.

# 使用f-string
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)  # 输出: Hello, my name is Alice and I am 30 years old.

  12. 字符串去除空白：
    使用strip()​方法去除字符串两端的空白字符。

    text = "  Hello, World!  "
print(text.strip())  # 输出: Hello, World!

  13. 字符串查找位置：
    使用find()​或index()​方法查找子字符串的位置。

    text = "Python is great"
print(text.find("is"))  # 输出: 7
print(text.index("is")) # 输出: 7

  14. 字符串转换为列表：
    使用list()​函数将字符串转换为字符列表。

    text = "Python"
char_list = list(text)
print(char_list)  # 输出: ['P', 'y', 't', 'h', 'o', 'n']

  15. 字符串比较：
    使用比较运算符比较字符串。

    text1 = "Python"
text2 = "python"
print(text1 > text2)  # 输出: True，因为字符串按字典顺序比较

转义字符

在Python中，转义字符用于表示那些无法直接通过键盘输入的字符，或者那些在字符串中有特殊含义的字符。

这些转义字符和序列在处理文件路径、特殊字符和国际化文本时非常有用。正确使用转义字符可以帮助你避免许多常见的字符串处理错误。

  1. 换行符 (\n​):
    用于在字符串中表示换行。

    print("Hello\nWorld")
# 输出:
# Hello
# World

  2. 制表符 (\t​):
    用于在字符串中表示制表符，通常用于对齐文本。

    print("Hello\tWorld")
# 输出:
# Hello    World

  3. 单引号 (\'​):
    用于在字符串中包含单引号。

    print("It's a beautiful day.")
# 输出: It's a beautiful day.

  4. 双引号 (\"​):
    用于在字符串中包含双引号。

    print("She said, \"Hello World\".")
# 输出: She said, "Hello World".

  5. 反斜杠 (\\​):
    用于在字符串中包含反斜杠。

    print("C:\\Users\\Username")
# 输出: C:\Users\Username

  6. 转义序列:
    用于表示特定的字符，如\a​表示响铃，\b​表示退格等。

    print("\a")  # 响铃
print("\b")  # 退格

  7. 八进制转义序列 (\ooo​):
    用于表示ASCII码的八进制值。

    print("\101")  # 输出: A，因为A的ASCII码是65，八进制为101

  8. 十六进制转义序列 (\xhh​):
    用于表示ASCII码的十六进制值。

    print("\x41")  # 输出: A，因为A的ASCII码是65，十六进制为41

  9. 原始字符串:
    在字符串前加上r​或R​，表示原始字符串，不处理反斜杠作为转义字符。

    str1 = r"name\tage\tgender"
print(str1)  # 输出: name\tage\tgender

  10. Unicode转义序列 (\uxxxx​):
    用于表示Unicode字符。

    print("\u0041")  # 输出: A，因为A的Unicode码点是U+0041

  11. Unicode名称转义序列 (\N{name}​):
    用于表示Unicode字符的名称。

    print("\N{LATIN CAPITAL LETTER A}")  # 输出: A

‍

‍

列表（List）的基本操作

  1. 列表定义：

    • 列表是Python中使用最频繁的数据类型之一。

    • 列表可以包含不同类型的元素，元素之间用逗号分隔，整个列表用方括号[]​括起来。

  2. 列表索引：

    • 列表的索引从0开始，-1表示列表的最后一个元素。

    • 列表索引可以用来访问和修改列表中的元素。

  3. 列表切片：

    • 列表切片使用方括号[]​，格式为变量[头下标:尾下标]​。

    • 切片可以省略头下标或尾下标，省略头下标表示从头开始，省略尾下标表示直到列表末尾。

  4. 列表操作示例：

    • ​print(list)​：打印整个列表。

    • ​print(list[0])​：打印列表的第一个元素。

    • ​print(list[1:3])​：打印列表的第二个到第四个元素（不包括第四个元素）。

    • ​print(list[2:])​：打印列表从第三个元素开始到末尾的所有元素。

    • ​print(tinylist * 2)​：将列表tinylist​重复两次。

    • ​print(list + tinylist)​：将两个列表拼接在一起。

例子：

  1. 创建列表：
    使用方括号[]​创建列表。

    my_list = [1, 2, 3, 'a', 'b', 'c']

  2. 访问列表元素：
    使用索引访问列表中的元素。

    print(my_list[0])  # 输出: 1
print(my_list[-1]) # 输出: c

  3. 修改列表元素：
    直接通过索引赋值修改元素。

    my_list[0] = 'x'
print(my_list)  # 输出: ['x', 2, 3, 'a', 'b', 'c']

  4. 添加元素：
    使用append()​方法在列表末尾添加元素。

    my_list.append('d')
print(my_list)  # 输出: ['x', 2, 3, 'a', 'b', 'c', 'd']

  5. 插入元素：
    使用insert()​方法在指定位置插入元素。

    my_list.insert(1, 'y')
print(my_list)  # 输出: ['x', 'y', 2, 3, 'a', 'b', 'c', 'd']

  6. 删除元素：
    使用remove()​方法删除指定值的第一个匹配项。

    my_list.remove('a')
print(my_list)  # 输出: ['x', 'y', 2, 3, 'b', 'c', 'd']

  7. 清空列表：
    使用clear()​方法清空列表。

    my_list.clear()
print(my_list)  # 输出: []

  8. 列表切片：
    使用[start:stop:step]​语法切片列表。

    print(my_list[1:4])  # 输出: ['y', 2, 3]
print(my_list[::2])  # 输出: ['x', 3, 'c']

  9. 列表连接：
    使用+​运算符连接两个列表。

    list2 = [4, 5, 6]
combined = my_list + list2
print(combined)  # 输出: ['x', 'y', 2, 3, 'b', 'c', 'd', 4, 5, 6]

  10. 列表重复：
    使用*​运算符重复列表。

    repeated = my_list * 2
print(repeated)  # 输出: ['x', 'y', 2, 3, 'b', 'c', 'd', 'x', 'y', 2, 3, 'b', 'c', 'd']

  11. 列表长度：
    使用len()​函数获取列表长度。

    print(len(my_list))  # 输出: 7

  12. 列表排序：
    使用sort()​方法对列表进行排序。

    my_list = [3, 1, 4, 1, 5, 9, 2]
my_list.sort()
print(my_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]

  13. 列表反转：
    使用reverse()​方法反转列表。

    my_list.reverse()
print(my_list)  # 输出: [9, 5, 4, 3, 2, 1, 1]

  14. 列表推导式：
    使用列表推导式创建新列表。

    squares = [x**2 for x in range(6)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25]

  15. 列表查找：
    使用index()​方法查找元素的索引。

    print(my_list.index(5))  # 输出: 4

  16. 列表成员检查：
    使用in​关键字检查元素是否在列表中。

    print(5 in my_list)  # 输出: True

  17. 列表统计：
    使用count()​方法统计元素出现次数。

    print(my_list.count(1))  # 输出: 2

  18. 列表去重：
    使用set()​函数去重。

    unique_items = list(set(my_list))
print(unique_items)  # 输出: [1, 2, 3, 4, 5, 9]

元组（Tuple）数据类型

  1. 元组定义：

    • 元组是不可变的序列类型，一旦创建就不能被修改。

    • 元组中的元素可以是任何数据类型，包括其他元组。

    • 元组使用圆括号()​定义，或者在元素后跟逗号定义，例如：(1, 2, 3)​或1, 2, 3​。

  2. 元组推导式：

    • 元组推导式类似于列表推导式，用于创建元组。

    • 例子中的错误在于使用了赋值语句x = {x for x in tuple}​，这是不正确的。正确的元组推导式应该不包含赋值语句。

  3. 元组操作示例：

    • 创建元组：my_tuple = (1, 2, 3)​

    • 访问元组元素：print(my_tuple[0])​输出第一个元素

    • 遍历元组：for item in my_tuple: print(item)​

    • 元组推导式：squares = (x**2 for x in range(5))​

例子：

  1. 创建元组：
    使用圆括号()​创建元组，或者直接使用逗号分隔值。

    my_tuple = (1, 2, 3, 'a', 'b', 'c')
# 或者
my_tuple = 1, 2, 3, 'a', 'b', 'c'

  2. 访问元组元素：
    使用索引访问元组中的元素。

    print(my_tuple[0])  # 输出: 1
print(my_tuple[-1]) # 输出: c

  3. 遍历元组：
    使用循环遍历元组中的所有元素。

    for item in my_tuple:
    print(item)

  4. 元组切片：
    使用切片语法获取元组的一部分。

    print(my_tuple[1:4])  # 输出: (2, 3, 'a')
print(my_tuple[::2])  # 输出: (1, 3, 'b')

  5. 元组连接：
    使用+​运算符连接两个元组。

    tuple2 = (4, 5, 6)
combined = my_tuple + tuple2
print(combined)  # 输出: (1, 2, 3, 'a', 'b', 'c', 4, 5, 6)

  6. 元组重复：
    使用*​运算符重复元组。

    repeated = my_tuple * 2
print(repeated)  # 输出: (1, 2, 3, 'a', 'b', 'c', 1, 2, 3, 'a', 'b', 'c')

  7. 元组长度：
    使用len()​函数获取元组的长度。

    print(len(my_tuple))  # 输出: 6

  8. 元组推导式：
    使用元组推导式创建新的元组。

    squares = (x**2 for x in range(6))
print(list(squares))  # 输出: [0, 1, 4, 9, 16, 25]

  9. 元组查找：
    使用index()​方法查找元素的索引。

    print(my_tuple.index(3))  # 输出: 2

  10. 元组成员检查：
    使用in​关键字检查元素是否在元组中。

    print(3 in my_tuple)  # 输出: True

  11. 元组统计：
    使用count()​方法统计元素出现次数。

    print(my_tuple.count('a'))  # 输出: 1

  12. 元组解包：
    将元组中的元素分配给多个变量。

    a, b, c = my_tuple[0:3]
print(a, b, c)  # 输出: 1 2 3

  13. 元组转换：
    将元组转换为其他数据结构，如列表或集合。

    list_from_tuple = list(my_tuple)
set_from_tuple = set(my_tuple)
print(list_from_tuple)  # 输出: [1, 2, 3, 'a', 'b', 'c']
print(set_from_tuple)  # 输出: {1, 2, 3, 'a', 'b', 'c'}

  14. 元组比较：
    使用比较运算符比较元组。

    tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
print(tuple1 < tuple2)  # 输出:   True

‍

字典

字典（Dictionary）是Python中一种非常有用的内置数据类型，它存储了键值对（key-value pairs）。

  1. 字典的定义：

    • 字典是Python中一种非常有用的内置数据类型。

    • 字典是无序的对象集合，其中的元素是通过键来存取的，而不是通过偏移存取。

  2. 字典的特点：

    • 字典是一种映射类型，使用花括号{}​标识。

    • 字典中的键（key）必须是不可变类型。

    • 在同一个字典中，键必须是唯一的。

  3. 字典的基本操作：

    • 创建字典：使用花括号{}​或dict()​函数。

    • 访问字典中的值：通过键来访问。

    • 修改字典中的值：通过键来赋值。

    • 添加新的键值对：通过键来赋值。

    • 删除键值对：使用del​语句或pop()​方法。

    • 检查键是否存在：使用in​关键字。

    • 获取所有键：使用keys()​方法。

    • 获取所有值：使用values()​方法。

    • 获取所有键值对：使用items()​方法。

  4. 示例代码：

    • 创建一个空字典dict = {}​。

    • 向字典中添加键值对：dict['one'] = "1 - 说羽Sec"​和dict[2] = "2 - 说羽Sec"​。

    • 创建一个包含多个键值对的字典：tinydict = {'name': '小羽老师', 'code': 1, 'site': 'sec.54cto.com'}​。

    • 访问字典中的值：print(dict['one'])​和print(dict[2])​。

    • 打印整个字典：print(tinydict)​。

    • 打印所有键：print(tinydict.keys())​。

    • 打印所有值：print(tinydict.values())​。

示例

  1. 创建字典：
    使用花括号{}​创建字典。

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

  2. 访问字典中的值：
    使用键来访问字典中的值。

    print(my_dict['name'])  # 输出: Alice

  3. 修改字典中的值：
    直接通过键赋值来修改字典中的值。

    my_dict['age'] = 26
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}

  4. 添加新的键值对：
    直接通过键赋值来添加新的键值对。

    my_dict['email'] = 'alice@example.com'
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'}

  5. 删除键值对：
    使用del​语句或pop()​方法删除键值对。

    del my_dict['city']
# 或者
city = my_dict.pop('city')
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'email': 'alice@example.com'}

  6. 检查键是否存在：
    使用in​关键字检查键是否存在于字典中。

    if 'name' in my_dict:
    print("Name exists in the dictionary.")

  7. 获取所有键：
    使用keys()​方法获取字典中的所有键。

    keys = my_dict.keys()
print(list(keys))  # 输出: ['name', 'age', 'email']

  8. 获取所有值：
    使用values()​方法获取字典中的所有值。

    values = my_dict.values()
print(list(values))  # 输出: ['Alice', 26, 'alice@example.com']

  9. 获取所有键值对：
    使用items()​方法获取字典中的所有键值对。

    items = my_dict.items()
print(list(items))  # 输出: [('name', 'Alice'), ('age', 26), ('email', 'alice@example.com')]

  10. 字典推导式：
    使用字典推导式创建新的字典。

    squares = {x: x**2 for x in range(6)}
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

  11. 字典的get()​方法：
    使用get()​方法安全地访问字典中的值，如果键不存在则返回默认值。

    print(my_dict.get('name', 'Unknown'))  # 输出: Alice
print(my_dict.get('country', 'Unknown'))  # 输出: Unknown

  12. 字典的update()​方法：
    使用update()​方法更新字典，可以添加新的键值对或修改现有的键值对。

    my_dict.update({'age': 27, 'country': 'USA'})
print(my_dict)  # 输出: {'name': 'Alice', 'age': 27, 'email': 'alice@example.com', 'country': 'USA'}

  13. 字典的clear()​方法：
    使用clear()​方法清空字典。

    my_dict.clear()
print(my_dict)  # 输出: {}

  14. 字典的copy()​方法：
    使用copy()​方法复制字典。

    new_dict = my_dict.copy()
print(new_dict)  # 输出: {'name': 'Alice', 'age': 27, 'email': 'alice@example.com', 'country': 'USA'}

‍

‍

if

在Python中，if​语句用于基于条件执行不同的代码块。

基本语法

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

带有elif​和else​的if​语句

if condition1:
    # 如果条件1为真，执行这里的代码
elif condition2:
    # 如果条件1不为真且条件2为真，执行这里的代码
else:
    # 如果所有条件都不为真，执行这里的代码

示例

  1. 简单的if​语句：

    age = 18
if age >= 18:
    print("你已经成年了。")

  2. 带有elif​的if​语句：

    score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
else:
    print("需要努力")

  3. 嵌套的if​语句：

    age = 20
gender = "男"
if age >= 18:
    if gender == "男":
        print("成年男性")
    else:
        print("成年女性")
else:
    print("未成年")

  4. 使用else​的if​语句：

    number = 10
if number > 5:
    print("数字大于5")
else:
    print("数字不大于5")

  5. 使用多个条件的if​语句：

    a = 10
b = 20
if a > b or a == b:
    print("a大于或等于b")

  6. 使用in​关键字的if​语句：

    colors = ["红", "绿", "蓝"]
if "绿" in colors:
    print("绿色在列表中")

  7. 使用not​关键字的if​语句：

    is_raining = False
if not is_raining:
    print("没有下雨，可以出门")

‍

​while​循环

在Python中，while​循环是一种基本的循环结构，用于在满足特定条件时重复执行一段代码。

基本语法

while condition:
    # 只要条件为真，就执行这里的代码

示例

  1. 简单的while​循环：

    i = 1
while i <= 5:
    print(i)
    i += 1

  2. 使用break​退出循环：
    ​break​语句用于立即退出循环，无论循环条件是否为真。

    i = 1
while i < 10:
    if i == 5:
        break
    print(i)
    i += 1

  3. 使用continue​跳过当前循环的剩余部分：
    ​continue​语句用于跳过当前循环的剩余部分，直接进入下一次循环。

    i = 1
while i < 10:
    if i % 2 == 0:
        continue
    print(i)
    i += 1

  4. 使用not​、or​、is​在条件中：

    i = 1
while not i > 5:
    print(i)
    i += 1

# 使用or
i = 0
while i < 5 or i > 10:
    print(i)
    i += 1

# 使用is
a = None
while a is not None:
    print(a)
    a = None

  5. 无限循环：
    如果循环条件始终为真，将创建无限循环。

    while True:
    print("这是一个无限循环")
    # 需要某种条件或外部事件来打破循环

  6. 循环中的逻辑判断：
    在循环中，可以根据需要使用逻辑判断来控制循环的执行。

    i = 0
while i < 10:
    if i == 3:
        print("跳过3")
        continue
    if i == 7:
        print("退出循环")
        break
    print(i)
    i += 1

​for​循环

​for​循环是一种常用的循环结构，用于遍历序列（如列表、元组、字典、集合等）或其他可迭代对象。

基本语法

for element in iterable:
    # 对每个元素执行这里的代码

示例

  1. 遍历列表：

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

  2. 遍历字符串：

    for char in "Hello":
    print(char)

  3. 遍历字典：

    person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key in person:
    print(key, person[key])

  4. 遍历字典的键值对：

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

  5. 使用range()​函数：
    ​range()​函数可以生成一个整数序列，常用于for​循环。

    for i in range(5):
    print(i)

  6. 遍历多个序列：
    使用zip()​函数可以同时遍历多个序列。

    colors = ['red', 'green', 'blue']
shapes = ['circle', 'square', 'triangle']
for color, shape in zip(colors, shapes):
    print(color, shape)

  7. 使用enumerate()​函数：
    ​enumerate()​函数可以同时获取元素的索引和值。

    for index, fruit in enumerate(fruits):
    print(index, fruit)

  8. 使用break​退出循环：
    ​break​语句用于立即退出循环。

    for i in range(10):
    if i == 5:
        break
    print(i)

  9. 使用continue​跳过当前循环：
    ​continue​语句用于跳过当前循环的剩余部分，直接进入下一次循环。

    for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

  10. 遍历文件：
    使用for​循环可以逐行读取文件内容。

    with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())

  1. 两种在Python中创建列表的方法：

    1. 列表推导式：

      • ​list = [x for x in range(1, 11)]​

      • 这是一种简洁的方法，用于从range(1, 11)​生成一个列表，其中包含从1到10的整数。

      • 使用列表推导式创建列表

        list = [x for x in range(1, 11)]
print(list)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    2. 使用for​循环和append()​方法：

      • 首先创建一个空列表：list1 = []​

      • 然后使用for​循环遍历range(1, 11)​：

        • ​for i in range(1, 11):​

          • 在每次循环中，使用append()​方法将当前的i​值添加到list1​中：

            • ​list1.append(i)​

      • 最后，使用print(list)​打印出列表list​，这个列表包含了从1到10的整数。

      • 使用for循环和append方法创建列表

        list1 = []
for i in range(1, 11):
    list1.append(i)
print(list1)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    这两种方法都会生成相同的结果，即一个包含数字1到10的列表。列表推导式是一种更简洁和表达式丰富的方式来创建列表，而使用for​循环和append()​方法则更直观，适合那些不熟悉列表推导式的人。

def函数

在Python中，def​关键字用于定义函数，这是一种封装代码以便于重用的机制。以下是def​函数的基本操作和详细使用过程，以及一些例子：

基本语法

def function_name(parameters):
    # 函数体，可以包含多条语句
    return value  # 可选，用于返回一个值

示例

  1. 无参数无返回值的函数：

    def greet():
    print("Hello, World!")

greet()  # 输出: Hello, World!

  2. 有参数无返回值的函数：

    def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # 输出: Hello, Alice!

  3. 无参数有返回值的函数：

    def get_sum():
    return 1 + 2

result = get_sum()  # result 现在是 3
print(result)  # 输出: 3

  4. 有参数有返回值的函数：

    def add_numbers(a, b):
    return a + b

result = add_numbers(3, 4)  # result 现在是 7
print(result)  # 输出: 7

  5. 带有默认参数的函数：

    def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Alice")  # 输出: Hello, Alice!
greet("Bob", "Hi")  # 输出: Hi, Bob!

  6. 带有可变参数的函数：

    def add_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

result = add_numbers(1, 2, 3, 4, 5)
print(result)  # 输出: 15

  7. 带有关键字参数的函数：

    def print_info(name, age, **kwargs):
    print(f"Name: {name}, Age: {age}")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info("Alice", 25, city="New York", country="USA")

  8. 递归函数：

    def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出: 120

  1. 这段代码展示了Python中函数的定义和调用，以及如何使用if __name__ == '__main__':​来判断当前脚本是否作为主程序运行。以下是代码的详细解释：

    1. 定义函数get_class()​：

      def get_class():
    print("调用了第二个方法")
    pass

      • 这个函数打印一条消息“调用了第二个方法”，然后执行pass​语句，pass​是一个空操作，不做任何事情。

    2. 定义函数get_name()​：

      def get_name():
    print("这是第一个方法")
    get_class()

      • 这个函数首先打印一条消息“这是第一个方法”，然后调用get_class()​函数。

    3. 主程序入口：

      if __name__ == '__main__':
    print("程序的主入口")
    get_name()

      • 这行代码检查当前模块是否是主程序运行，而不是被导入到其他模块中。如果是主程序，它将打印“程序的主入口”，然后调用get_name()​函数。

    当这个脚本作为主程序运行时，输出将会是：

    程序的主入口
这是第一个方法
调用了第二个方法

    ‍

迭代器（Iterator）和生成器（Generator）

迭代器是Python中访问集合元素的一种方式，它可以记住遍历的位置，并且只能往前不会后退。迭代器有两个基本的方法：iter()​和next()​。以下是迭代器的基本操作和详细使用过程，以及一些例子：

基本操作

  1. 创建迭代器对象：
    使用iter()​函数可以创建一个迭代器对象。

  2. 使用next()​方法：
    使用next()​方法可以获取迭代器的下一个元素。

  3. 使用for​循环遍历迭代器：
    迭代器对象可以直接在for​循环中使用，for​循环会自动调用next()​方法。

示例

  1. 使用iter()​和next()​：

    list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
print(next(it))  # 输出: 1
print(next(it))  # 输出: 2

  2. 使用for​循环遍历迭代器：

    list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
for x in it:
    print(x, end=" ")  # 输出: 1 2 3 4

  3. 使用生成器：
    生成器是一种特殊的迭代器，它使用yield​关键字来产生值。

    def my_generator():
    for i in range(5):
        yield i

gen = my_generator()  # 创建生成器对象
for value in gen:
    print(value, end=" ")  # 输出: 0 1 2 3 4

  4. 使用for​循环遍历字符串：
    字符串也是可迭代的，可以直接在for​循环中使用。

    for char in "Hello":
    print(char, end=" ")  # 输出: H e l l o

  5. 使用for​循环遍历字典：
    字典的键也是可迭代的，可以直接在for​循环中使用。

    person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key in person:
    print(key, person[key])  # 输出: name Alice age 25 city New York

异常处理

Python中的异常处理机制，使用try​和except​语句来捕获和处理程序运行时可能出现的错误。以下是异常处理的基本操作和详细使用过程，以及一些例子：

基本操作

  1. ​try​语句：

    • 用于包裹可能引发异常的代码块。

  2. ​except​语句：

    • 用于捕获try​块中引发的特定类型的异常，并提供处理异常的代码。

  3. ​break​语句：

    • 用于跳出循环，通常在异常处理中使用，以防止在捕获异常后继续执行循环。

示例

  1. 捕获并处理特定异常：

    while True:
    try:
        x = int(input("请输入一个数字: "))
        break
    except ValueError:
        print("您输入的不是数字，请再次尝试输入！")

  2. 捕获多个异常：

    try:
    # 假设这里有一些可能引发多种异常的代码
    pass
except (RuntimeError, TypeError, NameError):
    pass

  3. 使用else​子句：

    • 如果try​块中的代码没有引发异常，else​块中的代码将被执行。

    try:
    # 假设这里有一些可能引发异常的代码
    pass
except ValueError:
    print("捕获到ValueError异常")
else:
    print("没有异常发生")

  4. 使用finally​子句：

    • 无论是否发生异常，finally​块中的代码都会被执行。

    try:
    # 假设这里有一些可能引发异常的代码
    pass
except ValueError:
    print("捕获到ValueError异常")
finally:
    print("这是finally块，无论是否发生异常都会执行")

  5. 自定义异常：

    • 可以定义自己的异常类型。

    class MyCustomError(Exception):
    pass

try:
    # 假设这里有一些可能引发异常的代码
    raise MyCustomError("发生了自定义异常")
except MyCustomError as e:
    print(f"捕获到自定义异常: {e}")

文件读写的基本操作

使用open()​函数和with​语句来打开和读取文件。以下是文件读写的基本操作和详细使用过程，以及一些例子：

基本操作

  1. 使用open()​函数打开文件：

    • ​open(file, mode='r')​：file​是文件名，mode​是文件打开模式，默认为读取模式'r'​。

  2. 使用with​语句：

    • ​with​语句用于包裹文件操作代码，可以自动管理文件的打开和关闭。

示例

  1. 读取文件内容：

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

  2. 逐行读取文件：

    with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())  # 使用strip()去除行尾的换行符

  3. 写入文件：

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

  4. 追加内容到文件：

    with open('output.txt', 'a') as file:
    file.write("这是追加的一行文本。\n")

  5. 读取和写入二进制文件：

    # 读取二进制文件
with open('image.png', 'rb') as file:
    data = file.read()
    print(data)

# 写入二进制文件
with open('image.png', 'wb') as file:
    file.write(b"Binary data")

  6. 使用不同的文件模式：

    • ​'r'​：读取模式，默认值。

    • ​'w'​：写入模式，会覆盖文件内容。

    • ​'a'​：追加模式，会在文件末尾追加内容。

    • ​'b'​：二进制模式，用于非文本文件。

    • ​'+'​：更新模式，可以读写文件。

注意事项

  • 使用with​语句可以确保文件在使用后正确关闭，即使在读取或写入过程中发生异常也是如此。

  • 文件模式'w'​会覆盖原有文件内容，如果不想覆盖，可以使用'a'​追加模式或先检查文件是否存在。

  • 二进制模式'b'​用于处理非文本文件，如图片、音频等。

‍

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值