Python基础学习笔记

学习路径

1.学习变量

主要学习变量的命名方式

2.学习数据类型及类型转换

每个编程语言的类型种类不一样，需要学习有哪些种类，种类的表示方式和类型转换方法。
比如python的基本数据类型

整数（int）： 用来表示整数，例如 -5、0、42。

浮点数（float）： 用来表示带有小数点的数，例如 3.14、-0.001。

字符串（str）： 用来表示文本，例如 'Hello, World!'、"Python"。

布尔值（bool）： 用来表示真（True）或假（False）。

3.标识符

标识符主要学习就是变量命名的规则，一般都有如下规则

标识符可以是字母（小写或大写）、数字（但不能以数字开头）和下划线的组合。

标识符不能是保留字（关键字），例如 if、else、while等。

标识符对大小写敏感，例如 myVar 和 myvar 是不同的标识符。

运算符

以python为例，几乎所有语言都包含算术运算符、比较运算符、逻辑运算符

算术运算符：

+：加法
-：减法
*：乘法
 /：除法
%：取模（取余）
 //：整除
**：幂运算

赋值运算符及复合赋值运算符

+=： 加法赋值运算符
x += 3  # 等同于 x = x + 3

-=： 减法赋值运算符
*=： 乘法赋值运算符
/=： 除法赋值运算符
%=： 取模赋值运算符
//=： 整除赋值运算符
**=： 幂运算赋值运算符

比较运算符：

==：等于
!=：不等于
>：大于
<：小于
>=：大于等于
<=：小于等于

逻辑运算符：

and：与
or：或
not：非

有关字符串的操作

字符串的拼接

使用 + 运算符：

str1 = "Hello, "
str2 = "World!"

result = str1 + str2
print(result)
# 输出：Hello, World!

使用 .format() 方法：

name = "Alice"
age = 25

result = "My name is {}, and I am {} years old.".format(name, age)
print(result)
# 输出：My name is Alice, and I am 25 years old.

使用 % 格式化字符串：

name = "Charlie"
age = 22

result = "My name is %s, and I am %d years old." % (name, age)
print(result)
# 输出：My name is Charlie, and I am 22 years old.

使用 f-string（Python 3.6及以上版本）：

name = "Bob"
age = 30

result = f"My name is {name}, and I am {age} years old."
print(result)
# 输出：My name is Bob, and I am 30 years old.

数据输入

在Python中，input() 函数用于接收用户的输入。它允许用户在程序运行时输入数据，然后将输入的内容返回给程序。以下是一个简单的例子：

# 接收用户输入的名字
name = input("请输入您的名字: ")

# 打印输入的名字
print("您输入的名字是:", name)

请注意，input() 函数始终返回一个字符串。如果你期望输入的是一个数字，你可能需要使用 int() 或 float() 函数将其转换为相应的数值类型。

# 接收用户输入的年龄并将其转换为整数
age = int(input("请输入您的年龄: "))

# 打印输入的年龄
print("您输入的年龄是:", age)

判断语句

在Python中，判断语句主要使用 if、elif（可选）、else（可选）关键字来实现。以下是一个基本的判断语句的使用示例：

# 示例：根据用户输入的数字判断正负零
number = float(input("请输入一个数字: "))

if number > 0:
    print("这是一个正数")
elif number == 0:
    print("这是零")
else:
    print("这是一个负数")

随机数的使用

在Python中，可以使用 random 模块来生成随机数。以下是一些常见的随机数生成方法：
生成一个随机整数：

import random

# 生成一个范围在1到10之间的随机整数（包括1和10）
random_number = random.randint(1, 10)
print(random_number)

从序列中随机选择一个元素：

import random

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

# 从列表中随机选择一个元素
random_element = random.choice(my_list)
print(random_element)

从序列中随机选择一个元素：

import random

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

# 从列表中随机选择一个元素
random_element = random.choice(my_list)
print(random_element)

在使用随机数时，记得先导入 random 模块。根据实际需求，选择合适的方法来生成随机数。

循环语句

for 循环：

for 循环用于遍历一个可迭代对象（如列表、元组、字符串等），执行循环体中的代码块。

# 遍历列表中的元素
my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)
    
# 遍历字符串中的字符
my_string = "Hello"
for char in my_string:
    print(char)
使用 range() 生成数字序列进行循环
for i in range(5):
    print(i)

while 循环：

while 循环用于在条件为真的情况下执行代码块，直到条件变为假。

# 使用 while 循环计算 1 到 5 的和
sum_result = 0
counter = 1

while counter <= 5:
    sum_result += counter
    counter += 1

print("1 到 5 的和为:", sum_result)

# 使用 while 循环遍历列表
my_list = [1, 2, 3, 4, 5]
index = 0

while index < len(my_list):
    print(my_list[index])
    index += 1

可以使用 while 循环来创建一个无限循环。无限循环是一种没有明确终止条件的循环，它会一直执行

while True:
    print("这是一个无限循环!")

控制循环

在循环中，有一些关键字和语句可以用于控制循环的流程：
break： 用于跳出循环，终止循环的执行。

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

continue： 用于跳过当前循环中的剩余代码，进入下一次循环迭代。

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

else： 在循环条件为假时执行，除非在循环中遇到 break。

for i in range(5):
    print(i)
else:
    print("循环结束")

在嵌套循环中，循环控制语句只能作用在所在的循环上，无法对上层循环起作用

range() 函数

上面代码中的range() 函数用于生成一个表示数字范围的不可变序列。它常用于循环中。
range() 函数的基本语法如下：

range(stop)
range(start, stop, step)

start：可选，表示范围的起始值，默认为 0。
stop：必需，表示范围的结束值（不包含在范围内）。
step：可选，表示步长，默认为 1。

转义字符

换行符 \n： 表示一个换行符，用于在字符串中创建新的一行。
制表符 \t： 表示一个制表符，用于在字符串中创建水平制表符（Tab）。
回车符 \r： 表示一个回车符，通常用于将光标移动到当前行的开头。
原始字符串 r 前缀： 可以在字符串前加上 r 来表示原始字符串，其中转义字符不会被处理。

print(r"This is a raw string. \n and \t are not escaped.")

转义字符的使用

i=1
j=1
while j<=9:
    i=1
    while i<=j:
        print(f"{i}*{j}={i*j}\t",end="")
        i+=1
    print()
    j+=1
# 上面print种加\t不会出现按列排序的效果，是因为代码种print语句是循环输出的，
# print默认是打印一行，结尾自动换行，end传递一个空字符串，表示这个语句没结束。
能用\t的方式如下，再一个print语句里面
print("这是第一列\t这是第二列")

函数

在Python中，函数是一组执行特定任务的代码块，可以通过函数名来调用。先定义函数，后使用函数

以下是定义和使用函数的基本示例：

定义函数：

使用 def 关键字来定义函数，并在函数体内编写相应的代码块。

def greet(name):
    """
    这是一个简单的问候函数
    """
    print(f"Hello, {name}!")
    # 函数定义结束

# 调用函数
greet("Alice")

lambda函数定义（匿名函数）

格式：
lambda 参数：执行语句

add = lambda x, y: x + y
result = add(3, 5)
print(result)  # 输出：8

在这个例子中，lambda x, y: x + y 创建了一个匿名函数，接受两个参数 x 和 y，并返回它们的和。然后，将这个 lambda 函数赋给变量 add，最后调用 add(3, 5) 得到结果并打印。

参数设置

默认参数：

函数可以有默认参数，当调用函数时如果没有提供这些参数，将使用默认值。

def greet_with_default(name="Guest"):
    """
    这是一个带有默认参数的问候函数
    """
    print(f"Hello, {name}!")

# 调用函数
greet_with_default()        # 输出：Hello, Guest!
greet_with_default("Bob")   # 输出：Hello, Bob!

关键字参数：

关键字参数是通过参数名明确指定的，而不是通过它们在参数列表中的位置。以下是一个简单的例子：

def greet(name, greeting="Hello", punctuation="!"):
    """
    一个简单的示例函数，使用关键字参数。
    """
    print(greeting, name + punctuation)

# 使用关键字参数调用函数
greet(name="Alice", greeting="Hi", punctuation="!!!")
greet(name="Bob", punctuation="...")

可变参数：

函数可以接受可变数量的参数，使用 *args 来表示。args可变

def add_all(*args):
    """
    这是一个可变参数的加法函数
    """
    result = sum(args)
    return result

# 调用函数
total = add_all(1, 2, 3, 4, 5)
print(total)  # 输出：15

函数还可以接受键值对不同的参数传递，使用 **kwargs 来表示。kwargs可变

def print_info(**kwargs):
    """
    这是一个接受关键字参数的函数
    """
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用函数
print_info(name="Alice", age=25, city="Wonderland")
# 输出：
# name: Alice
# age: 25
# city: Wonderland

返回值：

函数可以返回一个值，使用 return 语句。

def add(a, b):
    """
    这是一个加法函数
    """
    result = a + b
    return result

# 调用函数并获取返回值
sum_result = add(3, 5)
print(sum_result)

如果函数没有使用return语句返回数据，那么函数有返回值吗?

Python中有一个特殊的字面量:None，其类型是:<class ‘NoneType’>无返回值的函数，实际上就是返回了: None这个字面量

python接收多个返回值
在Python中，一个函数可以通过 return 语句返回多个值。当调用这个函数时，可以使用多个变量来接收这些返回值。以下是一个简单的例子：

def multiple_values():
    return 1, 2, 3

# 调用函数并接收返回值
result1, result2, result3 = multiple_values()

# 打印接收到的值
print(result1)  # 输出: 1
print(result2)  # 输出: 2
print(result3)  # 输出: 3

另一种常见的方式是将返回的多个值存储在一个元组中，然后使用单个变量接收这个元组：

def multiple_values():
    return 1, 2, 3

# 调用函数并接收返回值
result = multiple_values()

# 打印整个元组
print(result)  # 输出: (1, 2, 3)

# 分别访问元组中的值
print(result[0])  # 输出: 1
print(result[1])  # 输出: 2
print(result[2])  # 输出: 3

函数的嵌套调用

函数可以嵌套调用，即在一个函数的代码块中调用另一个函数。这种嵌套调用的结构可以帮助你更好地组织和模块化代码。

def greet(name):
    """
    问候函数
    """
    return f"Hello, {name}!"

def welcome(name):
    """
    欢迎函数，调用问候函数
    """
    greeting = greet(name)
    return f"Welcome! {greeting}"

# 主程序
user_name = "Alice"
result = welcome(user_name)
print(result)

数据容器

在Python中，数据容器是一种用于存储和组织数据的数据结构。以下是一些常用的数据容器以及它们的基本用法：

列表（List）：

列表是有序的、可变的序列，用于存储一组元素。

my_list = [1, 2, 3, "apple", "orange", True]
print(my_list)

元组（Tuple）：

元组是有序的、不可变的序列，用于存储一组元素。如果想要传递的信息不被修改，就可使用元组。

my_tuple = (1, 2, 3, "apple", "orange", True)
print(my_tuple)

集合（Set）：

集合是无序的、不重复的元素集，用于存储唯一的元素。

my_set = {1, 2, 3, "apple", "orange", True}
print(my_set)

字典（Dictionary）：

字典是无序的键值对集合，用于存储通过键访问的值。

my_dict = {"name": "Alice", "age": 25, "city": "Wonderland"}
print(my_dict)

字典遍历方法

my_dict = {"name": "Alice", "age": 25, "city": "Wonderland"}

# 遍历键
print("Keys:")
for key in my_dict.keys():
    print(key)

# 遍历值
print("\nValues:")
for value in my_dict.values():
    print(value)

# 遍历键值对
print("\nItems:")
for key, value in my_dict.items():
    print(f"{key}: {value}")

字符串（String）：

字符串是有序的字符序列，用于存储文本数据。
字符串切片

my_string = "Hello, Python!"
substring = my_string[7:13]
print(substring)  # 输出：Python

字符串长度

my_string = "Hello, Python!"
length = len(my_string)
print(length)  # 输出：15

字符串查找

my_string = "Hello, Python!"
index = my_string.find("Python")
print(index)  # 输出：7

字符串替换

my_string = "Hello, Python!"
new_string = my_string.replace("Python", "World")
print(new_string)  # 输出：Hello, World!

字符串分割

my_string = "apple,orange,banana"
fruits = my_string.split(",")
print(fruits)  # 输出：['apple', 'orange', 'banana']
字符串大小写转换：
my_string = "Hello, Python!"
lowercase = my_string.lower()
uppercase = my_string.upper()
print(lowercase)  # 输出：hello, python!
print(uppercase)  # 输出：HELLO, PYTHON!

判断字符串开头或结尾

my_string = "Hello, Python!"
starts_with_hello = my_string.startswith("Hello")
ends_with_python = my_string.endswith("Python!")
print(starts_with_hello)  # 输出：True
print(ends_with_python)   # 输出：True

数据容器的使用方法

访问元素

# 列表和元组
print(my_list[0])       # 输出：1
print(my_tuple[1])      # 输出：2
print(my_tuple[-1])     #输出：True，输出倒数第一个

# 字典
print(my_dict["age"])   # 输出：25

在Python中，取多层嵌套列表（多维列表）的元素可以通过多层索引进行。每个索引对应一个层级。以下是一个简单的例子，修改和删除以此类推。

# 二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 访问二维列表的元素
element = matrix[1][2]  # 第二行（索引1），第三列（索引2）
print(element)  # 输出：6

修改元素

# 列表
my_list[2] = 100
print(my_list)          # 输出：[1, 2, 100, "apple", "orange", True]

# 元组是不可变的，不能修改元素
# 字典
my_dict["city"] = "New Wonderland"
print(my_dict)          # 输出：{'name': 'Alice', 'age': 25, 'city': 'New Wonderland'}

添加元素

# 列表
my_list.append("banana")
print(my_list)          # 输出：[1, 2, 100, "apple", "orange", True, "banana"]

# 字典
my_dict["gender"] = "Female"
print(my_dict)          # 输出：{'name': 'Alice', 'age': 25, 'city': 'New Wonderland', 'gender': 'Female'}

删除元素

# 列表
my_list.remove("apple")
print(my_list)          # 输出：[1, 2, 100, "orange", True, "banana"]

# 字典
del my_dict["age"]
print(my_dict)          # 输出：{'name': 'Alice', 'city': 'New Wonderland', 'gender': 'Female'}

其他列表操作方法如下