Python基础

最新推荐文章于 2024-10-03 09:00:56 发布

算是难了

最新推荐文章于 2024-10-03 09:00:56 发布

阅读量1k

点赞数 15

文章标签： python 开发语言

本文链接：https://blog.csdn.net/2301_76662406/article/details/142650607

版权

Python基础

在这里插入图片描述

变量

什么是变量?

程序中：变量是一个可以在程序运行（计算）中变化的量,变量具有名字和值这两个重要属性

简单的说，变量就是在程序运行时，记录数据用的

变量名:

变量名是用来标识变量的名称。通过这个名字，程序可以引用和操作存储在该变量中的值。
变量名应该具有描述性，以便让代码更易读。例如，使用 age 来表示年龄，使用 total_price 来表示总价格。

变量的值:

变量的值是存储在变量中的数据。这个值可以是不同的数据类型，例如整型、浮点型、字符串或布尔型。
在声明一个变量时，必须确保给它赋一个初始值。
```
score = 100  # score 变量的值是 100
name = "Alice"
```

变量的命名:

命名规则：
- 变量名必须以字母（a-z、A-Z）或下划线（_）开头。不能以数字开头
- 变量名可以包含字母、数字（0-9）和下划线，但不能包含空格和特殊字符（如 @、#、$ 等）。
- 变量名是区分大小写的，例如 myVar 和 myvar 是两个不同的变量。
常用命名风格:

小写字母命名法（snake_case）

使用小写字母，单词之间用下划线分隔。
常用于变量和函数命名。

大写字母命名法（PascalCase）

每个单词的首字母大写，且没有下划线。
常用于类名。

全部大写字母命名法（UPPERCASE）

所有字母大写，单词之间用下划线分隔。
常用于常量命名。

单下划线开头（_single_leading_underscore）

表示该变量或方法是“受保护的”，不应在类外部直接访问。

class MyClass:
    def __init__(self):
        self._protected_member = 42

双下划线开头（__double_leading_underscore）

用于实现名称改写，通常用于类的私有属性。

class MyClass:
    def __init__(self):
        self.__private_member = 10

变量的赋值:

x = 10          # 将整数 10 赋值给变量 x
y = "Hello"     # 将字符串 "Hello" 赋值给变量 y

使用变量:

一旦定义了变量，就可以在程序中使用它们。例如，你可以进行打印、计算或其他操作：

# 打印变量的值
print(name)  # 输出: Alice

# 进行计算
total_age = age + 5
print(total_age)  # 输出: 30

基本数据类型:

name = "Alice"  # 字符串类型
age = 25        # 整型
height = 5.7    # 浮点型
is_student = True  # 布尔型

使用type()检验数据类型:

语法：

type(变量名) || type(变量值)

print(type(name) # str
print(type("Alice") # str

常见的转换语句:

在这里插入图片描述

表达式:

1. 算术表达式

用于执行基本的数学运算。

a = 10
b = 5
result = a + b  # 加法
result = a - b  # 减法
result = a * b  # 乘法
result = a / b  # 除法
result = a // b  # 除法_整除
result = a % b  # 取余
result = a ** b # 幂运算

2. 比较表达式

用于比较两个值，返回布尔值（True或False）。

x = 10
y = 20
result = x < y    # 小于
result = x == y   # 等于
result = x != y   # 不等于
result = x >= y   # 大于等于
result = x <= y   # 小于等于

3. 逻辑表达式

用于逻辑运算。|| &&

a = True
b = False
result = a and b  # 逻辑与
result = a or b   # 逻辑或
result = not a    # 逻辑非

链式表达:

x = 5
y = 10
z = 15

# 检查多个条件
result2 = (x < y) and (y < z) and (x < z)  # 所有条件都为 True

4. 字符串表达式

用于字符串的连接和操作。

first_name = "John"
last_name = "Doe"
full_name = first_name + "" + last_name  # 字符串连接
a=1
b=2
c=""+a+""+b #12

5. 条件表达式

用于根据条件选择值。

三元运算符:

语法:

result = value_if_true if condition else value_if_false

condition：一个布尔表达式（返回 True 或 False）。
value_if_true：当条件为 True 时返回的值。
value_if_false：当条件为 False 时返回的值。

举例:

x = 5
result = 1 if x > 0 else 2345  # 三元表达式

一个更复杂的例子:

x = -5
result = "Positive" if x > 0 else "Zero" if x == 0 else "Negative"
result ="Zero" if x == 0 else "Negative"
print(result)  # 输出: Negative

字符串

1. 字符串的定义

字符串可以用单引号、双引号或三引号定义。

single_quote = 'Hello, World!'
double_quote = "Hello, World!"
# ffjhghjgj
triple_quote = '''This is a
multi-line string.'''

2. 字符串的拼接

可以使用 + 运算符将多个字符串连接在一起。

greeting = "Hello"
name = "Alice"
message = greeting + ", " + name + "!"  # 结果是 "Hello, Alice!"

3. 字符串的重复

可以使用 * 运算符重复字符串。

repeat = "na" * 4  # 结果是 "nananana"

4. 访问字符串中的字符

可以通过索引访问字符串中的特定字符，索引从0开始。

text = "Python"
first_char = text[0]  # 结果是 'P'
last_char = text[-1]  # 结果是 'n'

5. 字符串方法

Python提供了许多内置字符串方法，常用的包括：

upper()：将字符串转换为大写。

text = "hello"
upper_text = text.upper()  # 结果是 "HELLO"

lower()：将字符串转换为小写。

text = "HELLO"
lower_text = text.lower()  # 结果是 "hello"

strip()：去除字符串两端的空白字符。

text = "   Hello, World!   "
stripped_text = text.strip()  # 结果是 "Hello, World!"

replace(old, new)：替换字符串中的子串。

text = "Hello, World!"
new_text = text.replace("World", "Python")  # 结果是 "Hello, Python!"

split(separator)：将字符串分割成列表。

text = "Hello, World,!"
words = text.split(", ")  # 结果是 ['Hello', 'World!']

join(iterable)：将可迭代对象中的字符串连接成一个字符串。

words = ['Hello', 'World']
sentence = " ".join(words)  # 结果是 "Hello World"

注意:在Python中，可迭代对象是指可以逐个返回其元素的对象。常见的可迭代对象包括列表、元组、字符串、字典和集合等,后面会讲

可迭代对象可以理解为一个集合，里面包含了同种类型的对象（一个班级,班级中的每一个学生对象）。它们可以被逐个访问和处理。

一个班上的总人数就是可以迭代的,每一个被迭代的对象就是班上的同学

7. 格式化字符串

可以使用格式化方法来插入变量到字符串中。

f-字符串（Python 3.6+）：

name = "Alice"
age = 30
message = f"My name is {name} and I am {age} years old."

format() 方法：

message = "My name is {} and I am {} years old.".format(name, age)

关系和逻辑运算

1. 关系运算

关系运算用于比较两个值，并返回布尔值（True 或 False）。常用的关系运算符包括：

等于 (==)：检查两个值是否相等。

a = 5
b = 5
result = (a == b)  # 结果是 True

不等于 (!=)：检查两个值是否不相等。
```
result = (a != b)  # 结果是 False
```
大于 (>)：检查左侧值是否大于右侧值。
```
result = (a > b)  # 结果是 False
```
小于 (<)：检查左侧值是否小于右侧值。
```
result = (a < b)  # 结果是 False
```
大于等于 (>=)：检查左侧值是否大于或等于右侧值。
```
result = (a >= b)  # 结果是 True
```
小于等于 (<=)：检查左侧值是否小于或等于右侧值。
```
result = (a <= b)  # 结果是 True
```

2. 逻辑运算

逻辑运算用于处理布尔值，常用的逻辑运算符包括：

逻辑与 (and)：当且仅当两个操作数都为 True 时，结果为 True。
```
x = True
y = False
result = x and y  # 结果是 False
```
逻辑或 (or)：只要有一个操作数为 True，结果就为 True。
```
result = x or y  # 结果是 True
```
逻辑非 (not)：反转布尔值。如果操作数为 True，结果为 False，反之亦然。
```
result = not x  # 结果是 False
```

3. 结合使用:

关系运算和逻辑运算可以结合使用，形成复杂的条件表达式。

a = 10
b = 20
c = 15

# 检查 a 是否大于 5 且 b 是否小于 25
result = (a > 5) and (b < 25)  # 结果是 True

# 检查 c 是否大于 10 或者 a 是否小于 5
result = (c > 10) or (a < 5)  # 结果是 True

# 检查 a 是否小于 5 的结果的非
result = not (a < 5)  # 结果是 True

输入与输出:

输入和输出是与用户交互的基本方式。

1. 输出语句

`print()` 函数

print() 是Python中最常用的输出函数，用于在控制台输出信息。

基本用法：

print("Hello, World!")  # 输出字符串

使用 end参数

print("Hello", end=" ")  # 输出: Hello! 
print("World")  # 输出: World

输出多个值：

name = "Alice"
age = 30
print("Name:", name, "Age:", age)  # 输出多个值，自动用空格分隔

格式化输出：

f-字符串（Python 3.6+）：

print(f"我的名字是{name} 我的年龄是 {age} ")

format() 方法：

print("我的名字是 {} 我的年龄是 {} years old.".format(name, age))

百分号格式化：

print("我的名字是 %s 我的年龄是 %d " % (name, age))

2. 输入语句

`input()` 函数

input() 函数用于从用户获取输入。它会暂停程序的执行，直到用户输入内容并按下回车键。

基本用法：

user_input = input("Please enter your name: ")
print("Hello, " + user_input + "!")

输入的类型：
input() 函数返回的数据类型是字符串。如果需要将输入转换为其他类型（如整数或浮点数），需要使用类型转换函数。

age = int(input("Please enter your age: "))  # 将输入转换为整数

3. 示例:

以下是一个简单的示例程序，演示如何使用输入和输出：

name = input("What is your name? ")
age = int(input("How old are you? "))

print(f"Hello, {name}! You are {age} years old.")

写个题:分数及格

总结

使用 print() 函数输出信息。
使用 input() 函数获取用户输入。
输入的内容默认是字符串，必要时需要进行类型转换。

分支和循环

一、分支结构

分支结构允许程序根据条件的真伪来决定执行的路径。最常用的分支结构是 if 语句。

二、`if` 判断语句

if 语句用于根据条件判断执行特定的代码块。基本语法如下：

if condition:
    # 当 condition 为 True 时执行的代码
elif another_condition:
    # 当另一个条件为 True 时执行的代码
else:
    # 当所有条件都为 False 时执行的代码

示例

age = 18

if age < 18:
    print("未成年")
elif age == 18:
    print("刚成年")
else:
    print("成年人")

写个题:判断闰年

三、循环

循环用于重复执行某段代码，直到满足某个条件为止。Python 中常用的循环有 for 循环和 while 循环。

1. `for` 循环

for 循环用于遍历可迭代对象（如列表、元组、字符串等）。

基本语法：

for item in iterable:
    # 对每个 item 执行的代码

示例

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

写个题:打印直角三角形

2. `while` 循环

while 循环根据条件执行代码块，当条件为 True 时持续执行。

基本语法：

while condition:
    # 当 condition 为 True 时执行的代码

示例

count = 0

while count < 5:
    print("Count:", count)
    count += 1

四、综合示例

结合分支和循环的示例：

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

for number in numbers:
    if number % 2 == 0:
        print(f"{number} 是偶数")
    else:
        print(f"{number} 是奇数")

总结

分支结构：允许根据条件选择执行路径，常用的有 if、elif 和 else。
for 循环：用于遍历可迭代对象，执行固定次数。
while 循环：根据条件执行代码，直到条件不再满足。

递归实现最大公约数

def gcd(a, b):
    # 基本情况
    if b == 0:
        return a
    else:
        # 递归调用
        return gcd(b, a % b)

 a=   mid*xxx    b=mid*iii
# 测试用例
print(gcd(48, 18))  # 输出: 6
print(gcd(56, 98))  # 输出: 14
print(gcd(101, 10)) # 输出: 1

容器:

1.字符串 (String)

定义：字符串是字符的序列，用于表示文本数据。前面只提到如何创建
创建：可以用单引号或双引号创建字符串。
```
str1 = 'Hello'
str2 = "World"
```

基本操作：

连接：使用 + 运算符。
重复：使用 * 运算符。
索引：通过索引访问单个字符（从 0 开始）。

greeting = str1 + " " + str2  # 'Hello World'
repeated = str1 * 3  # 'HelloHelloHello'
first_char = str1[0]  # 'H'

2.列表 (List)

定义：列表是一个有序的可变集合，可以存储不同类型的元素。

创建：

使用方括号 []。

my_list = [1, 2, 3, 'apple', 4.5]

使用 tuple() 函数。

my_tuple_from_function = tuple([1, 2, 3, 4, 5])  # 从列表创建

基本操作：
- 添加：使用 append() 方法。
- 插入：使用 insert() 方法。
- 删除：使用 remove() 方法或 pop() 方法。
- 索引：可以通过索引访问元素。
```
my_list.append('banana')  # [1, 2, 3, 'apple', 4.5, 'banana']
my_list[1] = 'orange'  # [1, 'orange', 3, 'apple', 4.5, 'banana']
```

切片

基本语法

sequence[start:end:step] # 开始索引:结束索引(不含):步长

定义切片：介绍如何从列表或元组中提取部分元素。包括基本的切片语法，如 list[start:end:step]。

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

清空列表

my_list[:] = []       # 清空列表

字符串切片：说明如何对字符串进行切片操作，提取子字符串。

my_string = "Hello, World!"
print(my_string[7:12])  # 输出: 'World'

反转序列：演示如何使用切片反转列表或字符串。

reversed_list = my_list[::-1]  # 输出: [5, 4, 3, 2, 1, 0]

3. 元组 (Tuple)

定义：元组是一个有序的不可变集合，适合存储固定数据。

创建：

使用圆括号 ()。

my_tuple = (1, 2, 3, 'apple', 4.5)

使用 list() 函数。

my_list_from_function = list((1, 2, 3, 4, 5))  # 从元组创建

基本操作：

索引：可以通过索引访问元素。
连接：可以用 + 运算符连接元组。

first_element = my_tuple[0]  # 1
new_tuple = my_tuple + (6, 7)  # (1, 2, 3, 'apple', 4.5, 6, 7)

切片适用于以下容器：

列表 (List)
元组 (Tuple)
字符串 (String)

只适合可以获取索引的

4. 集合 (Set)

定义：集合是一个无序的可变集合，元素是唯一的，不支持重复。

创建：

使用花括号 {} 。

my_set = {1, 2, 3, 4, 4}  # {1, 2, 3, 4}

set() 函数。

my_set_from_function = set([1, 2, 3, 4, 5])  # 从列表创建

基本操作：
- 添加：使用 add() 方法。
- 删除：使用 remove() 或 discard() 方法。
- 集合运算：可以进行交集、并集等操作。
```
my_set.add(5)  # {1, 2, 3, 4, 5}
union_set = my_set.union({6, 7})  # {1, 2, 3, 4, 5, 6, 7}
```

集合运算方法示例:

set_a = {1, 2, 3}
set_b = {3, 4, 5}

并集 (Union)

# 方法1：使用 `union()`
union_set = set_a.union(set_b)
print(union_set)  # 输出: {1, 2, 3, 4, 5}

# 方法2：使用 `|` 运算符
union_set = set_a | set_b
print(union_set)  # 输出: {1, 2, 3, 4, 5}

交集 (Intersection)

# 方法1：使用 `intersection()`
intersection_set = set_a.intersection(set_b)
print(intersection_set)  # 输出: {3}

# 方法2：使用 `&` 运算符
intersection_set = set_a & set_b
print(intersection_set)  # 输出: {3}

差集 (Difference)

# 方法1：使用 `difference()`
difference_set = set_a.difference(set_b)
print(difference_set)  # 输出: {1, 2}

# 方法2：使用 `-` 运算符
difference_set = set_a - set_b
print(difference_set)  # 输出: {1, 2}

对称差集 (Symmetric Difference)

对称差集操作返回在两个集合中存在但不是同时存在的元素。

# 方法1：使用 `symmetric_difference()`
symmetric_difference_set = set_a.symmetric_difference(set_b)
print(symmetric_difference_set)  # 输出: {1, 2, 4, 5}

# 方法2：使用 `^` 运算符
symmetric_difference_set = set_a ^ set_b
print(symmetric_difference_set)  # 输出: {1, 2, 4, 5}

子集与超集

判断子集：检查一个集合是否是另一个集合的子集。

set_c = {1, 2}
is_subset = set_c.issubset(set_a)  # 输出: True
print(is_subset)

判断超集：检查一个集合是否是另一个集合的超集。

is_superset = set_a.issuperset(set_c)  # 输出: True
print(is_superset)

4. 字典 (Dictionary)

定义：字典是一个无序的可变集合，以键值对的形式存储数据，键是唯一的。

创建：

使用花括号 {}。

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

使用 dict() 函数。

my_set_from_function = set([1, 2, 3, 4, 5])  # 从列表创建

基本操作：

访问：通过键访问值。
添加/更新：通过键赋值。
删除：使用 del 语句或 pop() 方法。

name = my_dict['name']  # 'Alice'
my_dict['age'] = 31  # 更新年龄
del my_dict['city']  # 删除城市

写个题:查找最高分学生

总结

字符串：用于表示文本数据，支持不可变操作。
列表：有序可变集合，适合存储多个数据项。
元组：有序不可变集合，适用于固定数据。
集合：无序可变集合，元素唯一，支持集合运算。
字典：无序可变集合，以键值对形式存储数据，适合快速查找。

字符串、列表、集合、字典、四种相互转化:

字符串列表集合字典是可改序列

1. 字符串 (String)

从字符串到列表：使用 list() 函数可以将字符串转换为字符列表。

my_string = "hello"
char_list = list(my_string)  # 输出: ['h', 'e', 'l', 'l', 'o']

从列表到字符串：使用 ''.join() 方法将字符列表连接为字符串。

char_list = ['h', 'e', 'l', 'l', 'o']
my_string = ''.join(char_list)  # 输出: "hello"

2. 列表 (List)

从列表到集合：使用 set() 函数将列表转换为集合，去除重复元素。
```
my_list = [1, 2, 2, 3, 4]
my_set = set(my_list)  # 输出: {1, 2, 3, 4}
```

从集合到列表：使用 list() 函数将集合转换为列表。

my_set = {1, 2, 3, 4}
my_list = list(my_set)  # 输出: [1, 2, 3, 4]

3. 集合 (Set)

从集合到字符串：可以将集合中的元素转换为字符串，首先转为列表再连接。

my_set = {'h', 'e', 'l', 'l', 'o'}
my_string = ''.join(list(my_set))  # 输出: 可能是 "helo"

从集合到字典：集合没有键值对，但可以将集合中的元素用作字典的键，值可以设置为 None 或其他。
```
my_set = {1, 2, 3}
my_dict = {key: None for key in my_set}  # 输出: {1: None, 2: None, 3: None}
```

4. 字典 (Dictionary)

从字典到列表：可以提取字典的键或值，分别转换为列表。

my_dict = {'a': 1, 'b': 2, 'c': 3}
keys_list = list(my_dict.keys())  # 输出: ['a', 'b', 'c']
values_list = list(my_dict.values())  # 输出: [1, 2, 3]

从字典到集合：可以提取字典的键或值，转换为集合。
```
my_set = set(my_dict.keys())  # 输出: {'a', 'b', 'c'}
```

总结

字符串 ↔ 列表：使用 list() 和 ''.join() 进行转换。
列表 ↔ 集合：使用 set() 和 list() 进行转换。
集合 ↔ 字典：集合可用作字典的键，字典可以提取键或值转换为集合。
字典 ↔ 列表：可以提取字典的键或值，转为列表。

⏰题目一:分数及格

输入一个分数判断是否及格,根据分数分别输出四个等级:A,B,C,D,不及格输出不及格

(100~90:A, 90~80:B, 80~70:C, 70~60:D)

用三元运算符的写法表示出:

def getScore2():

⏰题目二:判断闰年

编写一个Python函数 is_leap_year(year)，该函数接受一个整数参数 year，判断给定的年份是否为闰年。如果是闰年，函数返回 True；否则返回 False。

闰年的判断规则:

如果一个年份能被4整除，但不能被100整除，则是闰年。
如果一个年份能被400整除，则是闰年。
其他情况均为非闰年。

def is_leap_year(year):

预期输出:

对于输入 2020，输出应为 True。
对于输入 1900，输出应为 False。
对于输入 2000，输出应为 True。
对于输入 2021，输出应为 False。

⏰题目三:打印直角三角形

给定高度 n,打印一个直角三角形。

示例：

输入：n = 5

输出：

*
**
***
****
*****

扩展:打印全等三角形,下去自己研究吧,双重for循环

⏰题目四:查找最高分学生

编写一个Python函数 search()，该函数实现以下功能：

创建一个字典 scores，其中包含学生姓名作为键，分数作为值。例如：

scores = {"Alice": 85, "Bob": 90, "Charlie": 88}

查找并打印得分最高的学生的姓名。

注意:

使用字典的 keys()、values() 和 items() 方法来获取相应的信息。
实现逻辑以遍历字典，找到分数最高的学生，并输出其姓名。

def search():
        scores = {"Alice": 85, "Bob":90, "Charlie":88}

算是难了

关注

15
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

Python基础

Python基础

变量

什么是变量?

变量名:

变量的值:

变量的命名:

变量的赋值:

使用变量:

基本数据类型:

使用type()检验数据类型:

常见的转换语句:

表达式:

1. 算术表达式

2. 比较表达式

3. 逻辑表达式

4. 字符串表达式

5. 条件表达式

三元运算符:

字符串

1. 字符串的定义

2. 字符串的拼接

3. 字符串的重复

4. 访问字符串中的字符

5. 字符串方法

7. 格式化字符串

关系和逻辑运算

1. 关系运算

2. 逻辑运算

3. 结合使用:

输入与输出:

1. 输出语句

print() 函数

2. 输入语句

input() 函数

3. 示例:

总结

分支和循环

一、分支结构

二、if 判断语句

示例

三、循环

1. for 循环

示例

2. while 循环

示例

四、综合示例

总结

递归实现最大公约数

容器:

1.字符串 (String)

2.列表 (List)

切片

3. 元组 (Tuple)

4. 集合 (Set)

集合运算方法示例:

4. 字典 (Dictionary)

总结

字符串、列表、集合、字典、四种相互转化:

1. 字符串 (String)

2. 列表 (List)

3. 集合 (Set)

4. 字典 (Dictionary)

总结

⏰题目一:分数及格

⏰题目二:判断闰年

闰年的判断规则:

预期输出:

⏰题目三:打印直角三角形

⏰题目四:查找最高分学生

`print()` 函数

`input()` 函数

二、`if` 判断语句

1. `for` 循环

2. `while` 循环