前言

为什么要学习python？如果你是一个编程小白，我推荐你学习python，因为它简单，你不会在学习的一开始就被劝退；如果你是一个非python程序员，我推荐你学习python，因为它高效，比起其他编程语言，你可以编写更少的代码，更快的完成工作任务，这样你可以抽出更多的时间陪伴家人；如果你只想学一门编程语言，我推荐你学习python，因为它很万能，不论是在web、游戏、爬虫、还是科学计算、亦或是人工智能领域，python都有丰富的包和开源项目。如果你想进入人工智能领域，我推荐你学习python，因为它是人工智能领域最常用的开发语言，那些牛X的人工智能项目都是用python编写的。

既然python有这么多非学不可的理由，那就开始我们的python之旅吧。

如果你是一个程序员，你会知道几乎所有的编程语言的学习，都会从变量、算数运算、比较运算、逻辑运算、条件控制语句、循环控制语句、常用数据结构、函数和异常处理这些基础开始。接下来我们也是按照这个顺序来学习python。

一、变量、数据类型、操作符

1.定义变量

在 Python 中，不需要声明变量的类型，可以直接赋值：

#定义变量
x = 10       # 整数
y = 3.14     # 浮点数
name = "Alice"  # 字符串
is_student = True  # 布尔值

2.数据类型

整数（int）

整数可以是正数或负数，不带小数点：

a = 42
b = -7

浮点数（float）

浮点数是带小数点的数字：

pi = 3.14159
height = 1.75

字符串（str）

字符串是由一对引号包围的字符序列，可以使用单引号 ' 或双引号 "：

greeting = "Hello, world!"
message = 'Python is fun!'

布尔值（bool）

布尔值只有两个：True 和 False：

is_active = True
is_admin = False

3.注释

注释用于解释代码，并不会被 Python 解释器执行。有两种类型的注释：单行注释和多行注释。

单行注释

使用’#’开头的行：

# 这是一个单行注释
x = 5  # 这是一个内联注释

多行注释

使用三引号（单引号或双引号）包围的多行字符串作为注释：

"""
这是一个多行注释。
可以跨越多行。
"""

4.基本的输入输出

输出（print）

使用 ‘print()’ 函数可以输出数据到控制台

print("Hello, world!")
print(x)

输入（input）

使用 input() 函数可以从用户那里获取输入，输入默认是字符串类型：

name = input("Enter your name: ")
print("Hello, " + name + "!")

5.基本的操作符

算术操作符

常见的算术操作符包括加、减、乘、除、取余和幂：

a = 10
a = 10
b = 3
print(a + b)  # 加法，输出 13
print(a - b)  # 减法，输出 7
print(a * b)  # 乘法，输出 30
print(a / b)  # 除法，输出 3.3333333333333335
print(a % b)  # 取余，输出 1
print(a ** b) # 幂，输出 1000

比较操作符

比较操作符用于比较两个值，返回布尔值：

x = 5
y = 10
print(x == y)  # 等于，输出 False
print(x != y)  # 不等于，输出 True
print(x > y)   # 大于，输出 False
print(x < y)   # 小于，输出 True
print(x >= y)  # 大于等于，输出 False
print(x <= y)  # 小于等于，输出 True

逻辑操作符

逻辑操作符用于布尔值的运算：

a = True
b = False
print(a and b)  # 与，输出 False
print(a or b)   # 或，输出 True
print(not a)    # 非，输出 False

二、程序控制

1.条件语句

if语句

if 语句用于判断一个条件是否为真。如果条件为真，则执行相应的代码块。

x = 10
if x > 5:
    print("x is greater than 5")

`if...else` 语句

if...else 语句在 if 条件为假时执行 else 代码块。

x = 3
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")

`if...elif...else` 语句

if...elif...else 语句用于处理多个条件判断。

x = 7
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5 but not greater than 10")
else:
    print("x is 5 or less")

三元条件运算符

三元条件运算符是一种简写形式的 if...else 语句，用于在一行中进行条件判断。

x = 10 result = "x is even" if x % 2 == 0 else "x is odd"print(result)

嵌套 `if` 语句

嵌套 if 语句是在一个 if 语句的代码块中包含另一个 if 语句。

x = 15
if x > 10:
    print("x is greater than 10")
    if x > 20:
        print("x is also greater than 20")
    else:
        print("x is not greater than 20")

异常处理（`try...except` 语句）

try...except 语句用于捕获和处理异常，以防止程序崩溃。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

可以捕获多种类型的异常：

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
except TypeError:
    print("Invalid type")

`while` 循环中的条件控制：`break` 和 `continue`

while 循环用于在条件为真时重复执行代码块，可以使用 break 和 continue 进行控制。

break 语句用于提前退出循环

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

`continue`

continue 语句用于跳过本次循环的剩余代码，直接进入下一次循环。

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

`else` 子句与 `while` 循环

i = 0
while i < 5:
    print(i)
    i += 1
else:
    print("Loop ended without break")

2.循环语句

(1) for 循环

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

 # 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 遍历数字范围
for i in range(5):
    print(i)

# 遍历字典
ages = {"Alice": 30, "Bob": 25, "Charlie": 35}
for name, age in ages.items():
    print(f"{name} is {age} years old")

(2) while 循环

while 循环在条件为真时重复执行代码块。

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

(3)循环中断控制 break

break 语句用于终止循环，即使循环条件仍然为真。

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

(4) 循环中断控制 continue

continue 语句用于跳过当前循环的剩余代码，然后继续下一次循环。

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

三、常用数据结构

1.列表list()

Python 中的列表（list）是一种常用的数据结构，它是一个有序的、可变的、可以包含不同类型元素的集合。Python 提供了许多内置方法来操作和管理列表。以下是 Python 列表的常用方法及其详细介绍。

(1)添加元素

append()

在列表末尾添加一个元素。

fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')
print(fruits)  # 输出: ['apple', 'banana', 'cherry', 'orange']

insert()

在指定位置插入一个元素。

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'orange')
print(fruits)  # 输出: ['apple', 'orange', 'banana', 'cherry']

extend()

将另一个列表或可迭代对象的所有元素添加到列表末尾。

fruits = ['apple', 'banana', 'cherry']
fruits.extend(['orange', 'grape'])
print(fruits)  # 输出: ['apple', 'banana', 'cherry', 'orange', 'grape']

(2)移除元素

remove()

移除列表中第一个匹配的元素。
fruits = ['apple', 'banana', 'cherry', 'banana']
fruits.remove('banana')
print(fruits)  # 输出: ['apple', 'cherry', 'banana']

pop()

移除并返回列表中指定位置的元素。如果不指定位置，默认移除并返回最后一个元素。

fruits = ['apple', 'banana', 'cherry']
fruit = fruits.pop(1)
print(fruit)  # 输出: 'banana'
print(fruits)  # 输出: ['apple', 'cherry']

clear()

移除列表中的所有元素。

fruits = ['apple', 'banana', 'cherry']
fruits.clear()
print(fruits)  # 输出: []

(3)查找元素

index()

返回列表中第一个匹配元素的索引。

fruits = ['apple', 'banana', 'cherry']
index = fruits.index('banana')
print(index)  # 输出:

2.元组tuple()

Python 中的元组（tuple）是一种有序的、不可变的集合，通常用于存储一组相关的数据。元组的操作方法比列表少，因为元组是不可变的，不能修改其内容。以下是 Python 元组的常用方法及其详细介绍：

(1)创建元组

创建元组的语法非常简单，使用圆括号 () 将元素括起来。

# 创建一个空元组
empty_tuple = ()

# 创建一个包含多个元素的元组
fruits = ('apple', 'banana', 'cherry')

(2)访问元素

可以使用索引访问元组中的元素。

fruits = ('apple', 'banana', 'cherry')
print(fruits[0])  # 输出: 'apple'

(3)元组的常用方法

count()

返回指定元素在元组中出现的次数。

fruits = ('apple', 'banana', 'cherry', 'banana')
count = fruits.count('banana')
print(count)  # 输出: 2

index()

返回指定元素在元组中第一次出现的索引。

fruits = ('apple', 'banana', 'cherry')
index = fruits.index('banana')
print(index)  # 输出: 1

(4)元组的基本操作

长度

使用 len() 函数获取元组的长度。
fruits = ('apple', 'banana', 'cherry')
length = len(fruits)
print(length)  # 输出: 3

元素存在性检查

使用 in 关键字检查元素是否存在于元组中。

fruits = ('apple', 'banana', 'cherry')
print('banana' in fruits)  # 输出: True
print('grape' in fruits)   # 输出: False

连接元组

可以使用 + 运算符连接两个元组。

fruits = ('apple', 'banana')
more_fruits = ('cherry', 'orange')
all_fruits = fruits + more_fruits
print(all_fruits)  # 输出: ('apple', 'banana', 'cherry', 'orange')

复制元组

可以使用 * 运算符将元组复制多次。

fruits = ('apple', 'banana')
repeat_fruits = fruits * 2
print(repeat_fruits)  # 输出: ('apple', 'banana', 'apple', 'banana')

切片

可以使用切片操作获取元组的一个子集。

fruits = ('apple', 'banana', 'cherry', 'orange')
sub_fruits = fruits[1:3]
print(sub_fruits)  # 输出: ('banana', 'cherry')

(4)解包（Unpacking）

可以将元组中的元素解包到变量中。

fruits = ('apple', 'banana', 'cherry')
fruit1, fruit2, fruit3 = fruits
print(fruit1)  # 输出: 'apple'
print(fruit2)  # 输出: 'banana'
print(fruit3)  # 输出: 'cherry'

(6)嵌套元组

元组可以包含其他元组，形成嵌套结构。

nested_tuple = (('apple', 'banana'), ('cherry', 'orange'))
print(nested_tuple[0])  # 输出: ('apple', 'banana')
print(nested_tuple[0][1])  # 输出: 'banana'

(7)转换为列表

虽然元组是不可变的，但可以将其转换为列表，进行修改后再转换回元组。

fruits = ('apple', 'banana', 'cherry')
fruits_list = list(fruits)
fruits_list.append('orange')
fruits = tuple(fruits_list)
print(fruits)  # 输出: ('apple', 'banana', 'cherry', 'orange')

这些是 Python 中元组的常用方法和操作。元组作为一种不可变的数据结构，通常用于存储不需要修改的数据，同时提供了一些基本的操作方法来访问和处理其中的元素。

3.词典dict()

Python 中的词典（dictionary）是一种键值对集合，用于存储和快速查找数据。词典是可变的，并且键必须是唯一的和不可变的（通常是字符串或数字）。以下是 Python 中词典的常用方法及其详细介绍：

(1)创建词典

可以使用花括号 {} 或 dict() 函数来创建词典。

# 使用花括号创建词典
person = {
    'name': 'Alice',
    'age': 25,
    'city': 'New York'
}
# 使用 dict() 函数创建词典
person = dict(name='Alice', age=25, city='New York')

(2)访问元素

可以使用键来访问词典中的值。
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(person['name'])  # 输出: Alice
print(person['age'])   # 输出: 25

(3)添加或更新元素

可以使用键来添加新元素或更新现有元素。

person = {'name': 'Alice', 'age': 25}
person['city'] = 'New York'  # 添加新元素
person['age'] = 26  # 更新现有元素
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}

(4)删除元素

del

使用 del 关键字删除指定键值对。

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

pop()

使用 pop() 方法删除指定键并返回其值。如果键不存在，则会引发 KeyError。

person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
age = person.pop('age')
print(age)     # 输出: 25
print(person)  # 输出: {'name': 'Alice', 'city': 'New York'}

popitem()

使用 popitem() 方法删除并返回词典中的最后一个键值对（Python 3.7 及以上版本中是按插入顺序）。

person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
item = person.popitem()
print(item)    # 输出: ('city', 'New York')
print(person)  # 输出: {'name': 'Alice', 'age': 25}

clear()

使用 clear() 方法移除词典中的所有元素。
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
person.clear()
print(person)  # 输出: {}

(5)获取元素

get()

使用 get() 方法返回指定键的值，如果键不存在则返回默认值（默认是 None）

person = {'name': 'Alice', 'age': 25}
age = person.get('age')
city = person.get('city', 'Unknown')
print(age)   # 输出: 25
print(city)  # 输出: Unknown

(6)检查键存在性

使用 in 关键字检查键是否存在于词典中。

person = {'name': 'Alice', 'age': 25}
print('name' in person)  # 输出: True
print('city' in person)  # 输出: False

(7)获取所有键、值和键值对

keys()

使用 keys() 方法返回所有键的视图。
person = {'name': 'Alice', 'age': 25}
keys = person.keys()
print(keys)  # 输出: dict_keys(['name', 'age'])

values()

使用 values() 方法返回所有值的视图。

person = {'name': 'Alice', 'age': 25}
values = person.values()
print(values)  # 输出: dict_values(['Alice', 25])

items()

使用 items() 方法返回所有键值对的视图。

person = {'name': 'Alice', 'age': 25}
items = person.items()
print(items)  # 输出: dict_items([('name', 'Alice'), ('age', 25)])

(8)更新词典

update()

使用 update() 方法将另一个词典的键值对更新到当前词典中。

person = {'name': 'Alice', 'age': 25}
updates = {'age': 26, 'city': 'New York'}
person.update(updates)
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}

(9)复制词典

copy()

使用 copy() 方法返回词典的浅复制。
person = {'name': 'Alice', 'age': 25}
copy_person = person.copy()
print(copy_person)  # 输出: {'name': 'Alice', 'age': 25}

(10)字典推导式

使用字典推导式可以快速生成词典。

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

这些是 Python 中词典的常用方法。通过这些方法，可以方便地对词典进行增删改查等操作，有效地管理和处理数据。

4.集合set()

(1)创建集合

可以使用花括号 {} 或 set() 函数来创建集合。

# 使用花括号创建集合
fruits = {'apple', 'banana', 'cherry'}

# 使用 set() 函数创建集合
fruits = set(['apple', 'banana', 'cherry'])

(2)添加元素

add()

将一个元素添加到集合中。如果元素已经存在，则不会添加。

fruits = {'apple', 'banana'}
fruits.add('cherry')
print(fruits)  # 输出: {'apple', 'banana', 'cherry'}

update()

可以使用 update() 方法将多个元素添加到集合中。参数可以是列表、元组、字典等可迭代对象。

fruits = {'apple', 'banana'}
fruits.update(['cherry', 'orange'])
print(fruits)  # 输出: {'apple', 'banana', 'cherry', 'orange'}

(3)移除元素

remove()

从集合中移除指定元素。如果元素不存在，则会引发 KeyError。

fruits = {'apple', 'banana', 'cherry'}
fruits.remove('banana')
print(fruits)  # 输出: {'apple', 'cherry'}

discard()

从集合中移除指定元素。如果元素不存在，不会引发错误。

fruits = {'apple', 'banana', 'cherry'}
fruits.discard('banana')
print(fruits)  # 输出: {'apple', 'cherry'}
fruits.discard('orange')  # 不会引发错误

pop()

随机移除集合中的一个元素，并返回该元素。如果集合为空，则引发 KeyError。

fruits = {'apple', 'banana', 'cherry'}
fruit = fruits.pop()
print(fruit)
print(fruits)

clear()

移除集合中的所有元素。

fruits = {'apple', 'banana', 'cherry'}
fruits.clear()
print(fruits)  # 输出: set()

(4)集合运算

union()

返回两个集合的并集。

set1 = {'apple', 'banana'}
set2 = {'cherry', 'banana'}
union_set = set1.union(set2)
print(union_set)  # 输出: {'apple', 'banana', 'cherry'}

intersection()

返回两个集合的交集。

set1 = {'apple', 'banana'}
set2 = {'cherry', 'banana'}
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出: {'banana'}

difference()

返回一个集合与另一个集合的差集。

set1 = {'apple', 'banana', 'cherry'}
set2 = {'banana'}
difference_set = set1.difference(set2)
print(difference_set)  # 输出: {'apple', 'cherry'}

symmetric_difference()

返回两个集合的对称差集（即只在其中一个集合中存在的元素）。

set1 = {'apple', 'banana'}
set2 = {'cherry', 'banana'}
sym_diff_set = set1.symmetric_difference(set2)
print(sym_diff_set)  # 输出: {'apple', 'cherry'}

(5)其他常用方法

copy()

返回集合的浅复制。

fruits = {'apple', 'banana', 'cherry'}
copy_fruits = fruits.copy()
print(copy_fruits)  # 输出: {'apple', 'banana', 'cherry'}

isdisjoint()

判断两个集合是否不相交（即没有共同元素）。

set1 = {'apple', 'banana'}
set2 = {'cherry', 'orange'}
print(set1.isdisjoint(set2))  # 输出: True

issubset()

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

set1 = {'apple', 'banana'}
set2 = {'apple', 'banana', 'cherry'}
print(set1.issubset(set2))  # 输出: True

issuperset()

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

set1 = {'apple', 'banana', 'cherry'}
set2 = {'apple', 'banana'}
print(set1.issuperset(set2))  # 输出: True

(6)集合推导式

使用集合推导式可以快速生成集合。

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

这些是 Python 中集合的常用方法。通过这些方法，可以方便地对集合进行各种操作，如添加、移除元素，以及进行集合运算等。

Python基础（一）

相关文章