大家好,小编来为大家解答以下问题,零基础python背记手册pdf下载,python背记手册pdf免费下载,今天让我们一起来看看吧!
Source code download: 本文相关源码
python学习笔记
一、变量声明
在Python中,你只需要为变量指定一个名称,并为其赋值,变量的类型将根据所赋的值自动确定。这种动态类型的特性使得变量的定义变得简洁而灵活python的turtle画老虎。
请记住,尽管在Python中变量的类型是自动推断的,但它们仍然具有类型,并且变量的类型在运行时是可变的。这意味着你可以将一个变量赋予不同类型的值,而无需显式地更改变量的类型声明。
- Python的动态类型使得变量声明更加简洁灵活。
- 还有其他常用变量类型,如字节串和空值类型,可根据需要进一步学习和探索。
赋值操作
变量赋值使用等号(=)进行,将一个值赋给变量
x = 5
二、Python常见数据类型及操作示例
在Python中,有许多常见的数据类型,每种类型都有其特定的用途和操作。下面是一些常见的数据类型及其相关操作的示例:
1. 布尔类型(Bool)
- 布尔类型用于表示逻辑值,包括两个取值:True和False。
- 布尔类型的变量可以通过直接赋值True或False来声明。
- 布尔类型的变量可用于条件判断和逻辑运算。
# 布尔类型声明方式
bool1 = True
bool2 = False
# 布尔类型的逻辑运算
print(bool1 and bool2) # 逻辑与运算
print(bool1 or bool2) # 逻辑或运算
print(not bool1) # 逻辑非运算
2. 字符串类型(String)
- 字符串类型用于表示文本数据,由字符序列组成。
- 字符串可以使用单引号、双引号或三引号来声明。
- 字符串提供了许多内置方法,用于处理和操作文本数据。
# String 类型声明方式
str1 = 'Hello'
str2 = "World"
# 字符串的拼接
result = str1 + ' ' + str2
print(result) # 输出:Hello World
# 字符串的长度
print(len(str1)) # 输出:5
# 字符串的索引和切片
print(str1[0]) # 输出:H
print(str1[1:3]) # 输出:el
print(str1[-1]) # 输出:o
# 字符串的常用方法
print(str1.upper()) # 将字符串转为大写
print(str2.lower()) # 将字符串转为小写
print(str1.replace('H', 'J')) # 将字符串中的字符替换
print(str2.split('o')) # 使用指定字符分割字符串
3. 整数类型(Integer)
- 整数类型用于表示整数值,包括正整数、负整数和零。
- 整数可以直接赋值给变量来声明。
- 整数支持常见的数学运算,如加法、减法、乘法和除法。
# int 声明方式
int1 = 10
int2 = 5
# 数学运算
print(int1 + int2) # 加法
print(int1 - int2) # 减法
print(int1 * int2) # 乘法
print(int1 / int2) # 除法,得到浮点数
print(int1 // int2) # 除法,得到整数部分
print(int1 % int2) # 求余数
print(int1 ** int2) # 指数运算
4. 浮点数类型(Float)
- 浮点数类型用于表示带有小数部分的数值。
- 浮点数可以直接赋值给变量来声明。
- 浮点数支持数学运算,并提供一些常用的数学函数。
# float 声明方式
float1 = 3.14
float2 = 2.718
# 数学运算
print(float1 + float2) # 加法
print(float1 - float2) # 减法
print(float1 * float2) # 乘法
print(float1 / float2) # 除法
print(float1 ** float2) # 指数运算
# 常用数学函数
print(abs(-3.14)) # 绝对值
print(round(3.1415)) # 四舍五入
print(max(float1, float2)) # 最大值
print(min(float1, float2)) # 最小值
5. 列表类型(List)
- 列表类型用于存储多个值,可以包含不同类型的元素。
- 列表使用方括号 [] 来声明,元素之间使用逗号分隔。
- 列表提供了丰富的方法来操作和访问列表中的元素。
# list 声明方式
list1 = [1, 2, 3, 4, 5]
list2 = ['a', 'b', 'c']
# 访问列表元素
print(list1[0]) # 输出:1
print(list2[-1]) # 输出:c
# 修改列表元素
list1[0] = 10
print(list1) # 输出:[10, 2, 3, 4, 5]
# 添加元素
list2.append('d')
print(list2) # 输出:['a', 'b', 'c', 'd']
# 列表切片
print(list1[1:4]) # 输出:[2, 3, 4]
print(list2[:2]) # 输出:['a', 'b']
# 列表排序
list3 = [3, 1, 5, 2, 4]
list3.sort()
print(list3) # 输出:[1, 2, 3, 4, 5]
# 列表长度
print(len(list1)) # 输出:5
# 列表的常用方法
print(list1.count(3)) # 统计元素出现的次数
print(list2.index('b')) # 返回元素的索引位置
6. 字典类型(Dictionary)
- 字典类型用于存储键-值对的数据,类似于映射或哈希表。
- 字典使用花括号 {} 来声明,键和值之间使用冒号 : 分隔。
- 字典提供了一系列方法来操作和访问字典中的键和值。
# 字典声明方式
dict1 = {'name': 'Alice', 'age': 25, 'country': 'USA'}
# 访问字典中的值
print(dict1['name']) # 输出:Alice
print(dict1.get('age')) # 输出:25
# 修改字典中的值
dict1['age'] = 26
print(dict1) # 输出:{'name': 'Alice', 'age': 26, 'country': 'USA'}
# 添加键值对
dict1['gender'] = 'female'
print(dict1) # 输出:{'name': 'Alice', 'age': 26, 'country': 'USA', 'gender': 'female'}
# 删除键值对
del dict1['country']
print(dict1) # 输出:{'name': 'Alice', 'age': 26, 'gender': 'female'}
# 字典长度
print(len(dict1)) # 输出:3
# 字典的常用方法
print(dict1.keys()) # 返回所有键
print(dict1.values()) # 返回所有值
print(dict1.items()) # 返回所有键值对
7. 集合类型(Set)
- 集合类型用于存储一组唯一的元素,不包含重复值。
- 集合使用花括号 {} 或 set() 函数来声明。
- 集合提供了一系列方法来执行集合操作,如并集、交集和差集。
# set 声明方式
set1 = {1, 2, 3}
set2 = set([3, 4, 5])
# 添加元素
set1.add(4)
print(set1) # 输出:{1, 2, 3, 4}
# 移除元素
set1.remove(2)
print(set1) # 输出:{1, 3, 4}
# 并集
union_set = set1.union(set2)
print(union_set) # 输出:{1, 3, 4, 5}
# 交集
intersection_set = set1.intersection(set2)
print(intersection_set) # 输出:{3}
# 差集
difference_set = set1.difference(set2)
print(difference_set) # 输出:{1, 4}
# 判断元素是否在集合中
print(2 in set1) # 输出:False
print(3 in set2) # 输出:True
# 集合的长度
print(len(set1)) # 输出:3
# 集合的常用方法
set3 = {3, 4, 5, 6}
print(set1.issubset(set3)) # 判断是否是子集
print(set3.issuperset(set1)) # 判断是否是超集
8. 元组类型(Tuple)
- 元组类型用于存储不可变的序列,一旦创建就不能修改。
- 元组使用圆括号 () 或 tuple() 函数来声明。
- 元组可以包含不同类型的元素,通过索引访问。
# tuple 元组声明方式
tuple1 = ('apple', 'banana', 'cherry')
tuple2 = tuple([1, 2, 3])
# 访问元组中的元素
print(tuple1[0]) # 输出:apple
print(tuple2[-1]) # 输出:3
# 元组的切片
print(tuple1[1:3]) # 输出:('banana', 'cherry')
print(tuple2[:2]) # 输出:(1, 2)
元组长度
print(len(tuple1)) # 输出:3
# 元组的常用方法
print(tuple1.count('banana')) # 统计元素出现的次数
print(tuple2.index(2)) # 返回元素的索引位置
以上是Python中常见的数据类型及其操作示例。这些数据类型在实际编程中非常常用,你可以根据需要选择合适的数据类型来存储和处理数据。
三、运算符和表达式
在Python中,运算符和表达式用于执行各种计算和操作。通过运算符和表达式,你可以进行数值运算、逻辑判断和数据处理。
1. 算术运算符
Python提供了一系列算术运算符,用于执行基本的数值计算:
- 加法:+
- 减法:-
- 乘法:*
- 除法:/
- 取模(取余数):%
- 整除(取商的整数部分)://
- 幂运算:**
# 算术运算符示例
x = 10
y = 3
sum = x + y # 13
difference = x - y # 7
product = x * y # 30
quotient = x / y # 3.3333333333333335
remainder = x % y # 1
integer_division = x // y # 3
power = x ** y # 1000
2. 比较运算符
比较运算符用于比较两个值之间的关系,并返回布尔值(True或False):
- 等于:==
- 不等于:!=
- 大于:>
- 小于:<
- 大于等于:>=
- 小于等于:<=
# 比较运算符示例
x = 5
y = 10
result1 = x == y # False
result2 = x != y # True
result3 = x > y # False
result4 = x < y # True
result5 = x >= y # False
result6 = x <= y # True
3. 逻辑运算符
逻辑运算符用于对布尔值进行逻辑操作,并返回布尔值结果:
- 与:and
- 或:or
- 非:not
# 逻辑运算符示例
x = True
y = False
result1 = x and y # False
result2 = x or y # True
result3 = not x # False
4. 赋值运算符
赋值运算符用于给变量赋值,将右侧的值赋给左侧的变量:
- 简单赋值:=
- 加法赋值:+=
- 减法赋值:-=
- 乘法赋值:*=
- 除法赋值:/=
- 取模赋值:%=
- 整除赋值://=
- 幂赋值:**=
# 赋值运算符示例
x = 10
x += 5 # x = x + 5,结果为15
x -= 3 # x = x - 3,结果为12
x *= 2 # x = x * 2,结果为24
x /= 4 # x = x / 4,结果为6.0
x %= 3 # x = x % 3,结果为0.0
x //= 2 # x = x // 2,结果为0.0
x **= 3 # x = x ** 3,结果为0.0
5. 其他算符
除了上述常见的运算符,Python还提供了其他类型的运算符,如位运算符、成员运算符和身份运算符。这些运算符在特定情况下使用,用于执行更复杂的操作。
- 位运算符:用于对二进制位进行操作,包括按位与(&)、按位或(|)、按位异或(^)、按位取反(~)等。
- 成员运算符:用于检查一个值是否属于某个序列,包括in和not in。
- 身份运算符:用于比较对象的身份(内存地址),包括is和is not。
# 其他运算符示例
x = 10
y = 20
numbers = [1, 2, 3]
result1 = x & y # 0
result2 = x | y # 30
result3 = x ^ y # 30
result4 = ~x # -11
result5 = 2 in numbers # True
result6 = 4 not in numbers # True
result7 = x is y # False
result8 = x is not y # True
运算符和表达式是Python中常用的工具,它们能够进行各种计算和逻辑操作。掌握了这些基本知识后,你将能够进行数据处理、条件判断和循环控制等任务。
四、条件语句
条件语句用于根据条件的真假执行不同的代码块。在Python中,条件语句使用if、elif(可选)和else(可选)关键字来构建。
1. if语句
if语句用于执行一个代码块,当条件为真时执行。if语句的语法如下:
if condition:
# 执行代码块
- condition是一个布尔表达式,当其值为True时,执行代码块中的语句。
- 代码块必须使用缩进(通常是四个空格),表示属于if语句的范围。
# if语句示例
x = 10
if x > 5:
print("x大于5")
2. if-else语句
if-else语句用于在条件为真和条件为假时分别执行不同的代码块。if-else语句的语法如下:
if condition:
# 执行代码块1
else:
# 执行代码块2
- 当条件为真时,执行代码块1;否则,执行代码块2。
# if-else语句示例
x = 10
if x > 5:
print("x大于5")
else:
print("x不大于5")
3. if-elif-else语句
if-elif-else语句用于在多个条件中选择执行不同的代码块。if-elif-else语句的语法如下:
if condition1:
# 执行代码块1
elif condition2:
# 执行代码块2
else:
# 执行代码块3
- 当条件1为真时,执行代码块1;否则,检查条件2。
- 当条件2为真时,执行代码块2;否则,执行代码块3。
# if-elif-else语句示例
x = 10
if x > 10:
print("x大于10")
elif x < 10:
print("x小于10")
else:
print("x等于10")
条件语句是Python中控制程序流程的重要工具。通过合理使用条件语句,可以根据不同的条件执行不同的代码逻辑,实现灵活的程序控制。
五、循环语句
循环语句用于重复执行一段代码块,直到满足特定条件为止。Python提供了两种主要的循环语句:**for
循环和while
**循环。
1. for循环
**for
循环用于遍历可迭代对象(如列表、元组、字符串等),并对其中的每个元素执行相应的操作。for
**循环的语法如下:
for element in iterable:
# 执行代码块
- **
element
**是每次迭代过程中取得的当前元素。 - **
iterable
**是一个可迭代对象,包含要遍历的元素。 - 代码块是要在每次迭代中执行的操作。
# for循环示例
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
print(fruit)
上述代码会依次输出列表**fruits
**中的每个水果。
2. while循环
**while
循环用于在满足条件的情况下重复执行代码块,直到条件变为假为止。while
**循环的语法如下:
while condition:
# 执行代码块
- **
condition
是一个布尔表达式,当其值为True
时,继续执行代码块;当其值为False
**时,跳出循环。 - 代码块是要重复执行的操作。
# while循环示例
count = 0
while count < 5:
print(count)
count += 1
上述代码会从0开始逐步递增,每次循环打印当前的**count
值,直到count
**大于等于5时跳出循环。
3. 循环控制语句
在循环过程中,我们可以使用循环控制语句来控制循环的流程。Python提供了以下三种常用的循环控制语句:
- **
break
**语句:用于完全终止循环,并跳出循环体。 - **
continue
**语句:用于跳过当前循环迭代,进入下一次循环迭代。 - **
pass
**语句:用作占位符,表示一个空的代码块。
# 循环控制语句示例
for i in range(10):
if i == 3:
break
if i == 1:
continue
if i == 5:
pass
print(i)
上述代码会打印出0、2、4,并在i等于3时终止循环。
循环语句是Python中实现重复执行的强大工具。通过合理使用循环语句,可以有效地处理重复性任务,提高代码的复用性和效率。
六、函数
函数是一段可重复使用的代码块,用于完成特定的任务。通过将代码组织成函数,我们可以实现模块化的编程,提高代码的复用性和可维护性。
在Python中,函数的定义使用关键字def
,并遵循以下的语法结构:
def function_name(parameters):
# 执行代码块
return value
function_name
是函数的名称,用于在调用函数时进行引用。parameters
是函数的参数,可以根据需要指定零个或多个参数。- 代码块是函数要执行的操作。
return
语句用于指定函数的返回值。
下面是一个简单的函数示例:
def greet(name):
message = f"Hello, {name}!"
return message
# 调用函数
result = greet("Alice")
print(result)
在上述代码中,greet()
函数接受一个参数name
,然后构造一个问候消息并返回。最后,在调用函数时,我们将名字传递给函数,并打印函数的返回值。
1.参数
函数可以接受不同类型和数量的参数,以满足不同的需求。在Python中,参数可以分为以下几种类型:
- 位置参数:按照参数的位置进行传递,调用时必须按照定义的顺序提供参数。
- 默认参数:为参数提供默认值,如果在调用时未指定该参数的值,将使用默认值。
- 关键字参数:通过指定参数名来传递参数,可以任意顺序地指定参数。
- 可变参数:接受可变数量的参数,可以是位置参数或关键字参数。
下面是一些参数的示例:
# 位置参数示例
def add_numbers(a, b):
return a + b
result = add_numbers(3, 5)
print(result)
# 默认参数示例
def greet(name, message="Hello"):
return f"{message}, {name}!"
result1 = greet("Alice")
result2 = greet("Bob", "Hi")
print(result1)
print(result2)
# 关键字参数示例
def personal_info(name, age, country):
return f"{name} is {age} years old and lives in {country}."
result = personal_info(name="Alice", country="USA", age=25)
print(result)
# 可变参数示例
def sum_numbers(*args):
total = 0
for num in args:
total += num
return total
result = sum_numbers(1, 2, 3, 4, 5)
print(result)
2.返回值
函数可以使用return
语句返回一个值或一组值。如果函数没有明确的返回语句,将默认返回None
。
def multiply(a, b):
return a * b
result = multiply(3, 4)
print(result)
在上述代码中,**multiply()
函数接受两个参数并返回它们的乘积。我们将函数的返回值存储在变量result
**中,并打印出来。
3.作用域
在函数中声明的变量拥有函数级的作用域,也称为局部作用域。这意味着这些变量只能在函数内部访问。
def calculate():
result = 10 + 20
return result
print(calculate()) # 输出结果为 30
print(result) # 会抛出 NameError 异常
在上述代码中,变量**result
是在函数calculate()
内部声明的,因此只能在函数内部访问。在函数外部尝试访问该变量将引发NameError
**异常。
4.递归函数
递归函数是一种调用自身的函数。它可以用于解决需要重复执行相同任务的问题。在递归函数中,必须包含一个或多个停止条件,以避免无限循环。
下面是一个计算阶乘的递归函数示例:
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
result = factorial(5)
print(result)
在上述代码中,factorial()
函数使用递归调用来计算一个数的阶乘。当传递参数为0时,函数返回1,否则返回n * factorial(n-1)
。
5.Lambda函数
Lambda函数是一种匿名函数,可以用于简化代码和处理简单的函数逻辑。Lambda函数由关键字**lambda
**引导,并可以接受任意数量的参数。
add_numbers = lambda a, b: a + b
result = add_numbers(3, 4)
print(result)
在上述代码中,我们创建了一个Lambda函数**add_numbers
**,它接受两个参数并返回它们的和。然后,我们将参数传递给Lambda函数并打印结果。
以上是关于函数的简要介绍,函数是Python编程中非常重要的概念,能够提高代码的复用性和可读性。熟练掌握函数的使用方法将对你的编程技能和项目开发非常有益。