python学习笔记(一)—基础知识

python学习笔记

一、变量声明

在Python中,你只需要为变量指定一个名称,并为其赋值,变量的类型将根据所赋的值自动确定。这种动态类型的特性使得变量的定义变得简洁而灵活。

请记住,尽管在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编程中非常重要的概念,能够提高代码的复用性和可读性。熟练掌握函数的使用方法将对你的编程技能和项目开发非常有益。

  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值