Python基础学习

1. 语法

1.1 执行 Python 语法

正如我们在上一节中学习到的，可以直接在命令行中编写执行 Python 的语法：

>>> print("Hello, World!")
Hello, World!

或者通过在服务器上创建 python 文件，使用 .py 文件扩展名，并在命令行中运行它：

C:\Users\Your Name>python myfile.py

1.2 Python 缩进

缩进指的是代码行开头的空格。

在其他编程语言中，代码缩进仅出于可读性的考虑，而 Python 中的缩进非常重要。

Python 使用缩进来指示代码块。

实例

if 5 > 2:
  print("Five is greater than two!")

如果省略缩进，Python 会出错：

实例
语法错误：

if 5 > 2:
print("Five is greater than two!")

空格数取决于程序员，但至少需要一个。

实例

if 5 > 2:
 print("Five is greater than two!")  
if 5 > 2:
        print("Five is greater than two!") 

您必须在同一代码块中使用相同数量的空格，否则 Python 会出错：

实例
语法错误：

if 5 > 2:
 print("Five is greater than two!") 
        print("Five is greater than two!")

1.3 Python 变量

在 Python 中，变量是在为其赋值时创建的：

实例
Python 中的变量：

x = 5
y = "Hello, World!"

Python 没有声明变量的命令。

您将在 Python 变量 章节中学习有关变量的更多知识。

注释
Python 拥有对文档内代码进行注释的功能。

注释以 ＃ 开头，Python 将其余部分作为注释呈现：

实例
Python 中的注释：

#This is a comment.
print("Hello, World!")

2. 注释

2.1 创建注释

注释以 ＃ 开头，Python 将忽略它们：

实例

#This is a comment
print("Hello, World!")

注释可以放在一行的末尾，Python 将忽略该行的其余部分：

实例

print("Hello, World!") #This is a comment

注释不必是解释代码的文本，它也可以用来阻止 Python 执行代码：

实例

#print("Hello, World!")
print("Cheers, Mate!")

2.2 多行注释

Python 实际上没有多行注释的语法。

要添加多行注释，您可以为每行插入一个 ＃：

实例

#This is a comment
#written in
#more than just one line
print("Hello, World!")

或者，以不完全符合预期的方式，您可以使用多行字符串。

由于 Python 将忽略未分配给变量的字符串文字，因此您可以在代码中添加多行字符串（三引号），并在其中添加注释：

实例

"""
This is a comment
written in 
more than just one line
"""
print("Hello, World!")

3. 变量

3.1 创建变量

变量是存放数据值的容器。

与其他编程语言不同，Python 没有声明变量的命令。

首次为其赋值时，才会创建变量。

实例

x = 10
y = "Bill"
print(x)
print(y)

变量不需要使用任何特定类型声明，甚至可以在设置后更改其类型。

实例

x = 5 # x is of type int
x = "Steve" # x is now of type str
print(x)

字符串变量可以使用单引号或双引号进行声明：

实例

x = "Bill"

is the same as

x = 'Bill'

变量名称
变量可以使用短名称（如 x 和 y）或更具描述性的名称（age、carname、total_volume）。

3.2 Python 变量命名规则：

• 变量名必须以字母或下划线字符开头
• 变量名称不能以数字开头
• 变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
• 变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）
  请记住，变量名称区分大小写

3.3 向多个变量赋值

Python 允许您在一行中为多个变量赋值：

实例

x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)

您可以在一行中为多个变量分配相同的值：

实例

x = y = z = "Orange"
print(x)
print(y)
print(z)

输出变量
Python 的 print 语句通常用于输出变量。

如需结合文本和变量，Python 使用 + 字符：

实例

x = "awesome"
print("Python is " + x)

您还可以使用 + 字符将变量与另一个变量相加：

实例

x = "Python is "
y = "awesome"
z =  x + y
print(z)

对于数字，+ 字符用作数学运算符：

实例

x = 5
y = 10
print(x + y)

如果您尝试组合字符串和数字，Python 会给出错误：

实例

x = 10
y = "Bill"
print(x + y)

3.4 全局变量

在函数外部创建的变量（如上述所有实例所示）称为全局变量。

全局变量可以被函数内部和外部的每个人使用。

实例
在函数外部创建变量，并在函数内部使用它：

x = "awesome"

def myfunc():
  print("Python is " + x)

myfunc()

如果在函数内部创建具有相同名称的变量，则该变量将是局部变量，并且只能在函数内部使用。具有相同名称的全局变量将保留原样，并拥有原始值。

实例
在函数内部创建一个与全局变量同名的变量：

x = "awesome"

def myfunc():
  x = "fantastic"
  print("Python is " + x)

myfunc()

print("Python is " + x)

3.5 global 关键字

通常，在函数内部创建变量时，该变量是局部变量，只能在该函数内部使用。

要在函数内部创建全局变量，您可以使用 global 关键字。

实例
如果您用了 global 关键字，则该变量属于全局范围：

def myfunc():
  global x
  x = "fantastic"

myfunc()

print("Python is " + x)

另外，如果要在函数内部更改全局变量，请使用 global 关键字。

实例
要在函数内部更改全局变量的值，请使用 global 关键字引用该变量：

x = "awesome"

def myfunc():
  global x
  x = "fantastic"

myfunc()

print("Python is " + x)

4. 数据类型

4.1 内置数据类型

在编程中，数据类型是一个重要的概念。

变量可以存储不同类型的数据，并且不同类型可以执行不同的操作。

在这些类别中，Python 默认拥有以下内置数据类型：

4.2 获取数据类型

您可以使用 type() 函数获取任何对象的数据类型：

实例
打印变量 x 的数据类型：

x = 10
print(type(x))

4.3 设置数据类型

4.4 设定特定的数据类型

如果希望指定数据类型，则您可以使用以下构造函数：

在 Python 中，当您为变量赋值时，会设置数据类型：

5. 数字

5.1 概述

Python 中有三种数字类型：

int
float
complex
为变量赋值时，将创建数值类型的变量：

实例

x = 10   # int
y = 6.3  # float
z = 2j   # complex

如需验证 Python 中任何对象的类型，请使用 type() 函数：

实例

print(type(x))
print(type(y))
print(type(z))

5.2 Int

Int 或整数是完整的数字，正数或负数，没有小数，长度不限。

实例
整数：

x = 10
y = 37216654545182186317
z = -465167846

print(type(x))
print(type(y))
print(type(z))

5.3 Float

浮动或“浮点数”是包含小数的正数或负数。

实例
浮点：

x = 3.50
y = 2.0
z = -63.78

print(type(x))
print(type(y))
print(type(z))

浮点数也可以是带有“e”的科学数字，表示 10 的幂。

实例
浮点：

x = 27e4
y = 15E2
z = -49.8e100

print(type(x))
print(type(y))
print(type(z))

5.4 复数

复数用 “j” 作为虚部编写：

实例
复数：

x = 2+3j
y = 7j
z = -7j

print(type(x))
print(type(y))
print(type(z))

5.5 类型转换

您可以使用 int()、float() 和 complex() 方法从一种类型转换为另一种类型：

实例
从一种类型转换为另一种类型：

x = 10 # int
y = 6.3 # float
z = 1j # complex

5.6 把整数转换为浮点数

a = float(x)

5.7 把浮点数转换为整数

b = int(y)

5.8 把整数转换为复数：

c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))

注释：您无法将复数转换为其他数字类型。

5.9 随机数

Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数：

实例
导入 random 模块，并显示 1 到 9 之间的随机数：

import random

print(random.randrange(1,10))

6. Casting

6.1 指定变量类型

有时您可能需要为变量指定类型。这可以通过 casting 来完成。 Python 是一门面向对象的语言，因此它使用类来定义数据类型，包括其原始类型。

因此，使用构造函数完成在 python 中的转换：

int() - 用整数字面量、浮点字面量构造整数（通过对数进行下舍入），或者用表示完整数字的字符串字面量
float() - 用整数字面量、浮点字面量，或字符串字面量构造浮点数（提供表示浮点数或整数的字符串）
str() - 用各种数据类型构造字符串，包括字符串，整数字面量和浮点字面量
实例
整数：

x = int(1)   # x 将是 1
y = int(2.5) # y 将是 2
z = int("3") # z 将是 3

实例
浮点数：

x = float(1)     # x 将是 1.0
y = float(2.5)   # y 将是 2.5
z = float("3")   # z 将是 3.0
w = float("4.6")# w 将是 4.6

实例
字符串：

x = str("S2") # x 将是 'S2'
y = str(3)    # y 将是 '3'
z = str(4.0)  # z 将是 '4.0'

7. 字符串

7.1 字符串字面量

python 中的字符串字面量由单引号或双引号括起。

‘hello’ 等同于 “hello”。

您可以使用 print() 函数显示字符串字面量：

实例

print("Hello")
print('Hello')

7.2 用字符串向变量赋值

通过使用变量名称后跟等号和字符串，可以把字符串赋值给变量：

实例

a = "Hello"
print(a)

7.3 多行字符串

您可以使用三个引号将多行字符串赋值给变量：

实例
您可以使用三个双引号：

a = """Python is a widely used general-purpose, high level programming language. 
It was initially designed by Guido van Rossum in 1991 
and developed by Python Software Foundation. 
It was mainly developed for emphasis on code readability, 
and its syntax allows programmers to express concepts in fewer lines of code."""
print(a)

或三个单引号：

实例

a = '''Python is a widely used general-purpose, high level programming language. 
It was initially designed by Guido van Rossum in 1991 
and developed by Python Software Foundation. 
It was mainly developed for emphasis on code readability, 
and its syntax allows programmers to express concepts in fewer lines of code.'''
print(a)

注释：在结果中，换行符插入与代码中相同的位置。

7.4 字符串是数组

像许多其他流行的编程语言一样，Python 中的字符串是表示 unicode 字符的字节数组。

但是，Python 没有字符数据类型，单个字符就是长度为 1 的字符串。

方括号可用于访问字符串的元素。

实例
获取位置 1 处的字符（请记住第一个字符的位置为 0）：

a = "Hello, World!"
print(a[1])

7.5 裁切

您可以使用裁切语法返回一定范围的字符。

指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。

实例
获取从位置 2 到位置 5（不包括）的字符：

b = "Hello, World!"
print(b[2:5])

7.6 负的索引

使用负索引从字符串末尾开始切片：

实例
获取从位置 5 到位置 1 的字符，从字符串末尾开始计数：

b = "Hello, World!"
print(b[-5:-2])

7.7 字符串长度

如需获取字符串的长度，请使用 len() 函数。

实例

len() 函数返回字符串的长度：

a = "Hello, World!"
print(len(a))

7.8 字符串方法

Python 有一组可用于字符串的内置方法。

实例
strip() 方法删除开头和结尾的空白字符：

a = " Hello, World! "
print(a.strip()) # returns "Hello, World!"

实例
lower() 返回小写的字符串：

a = "Hello, World!"
print(a.lower())

实例
upper() 方法返回大写的字符串：

a = "Hello, World!"
print(a.upper())

实例
replace() 用另一段字符串来替换字符串：

a = "Hello, World!"
print(a.replace("World", "Kitty"))

实例
split() 方法在找到分隔符的实例时将字符串拆分为子字符串：

a = "Hello, World!"
print(a.split(",")) # returns ['Hello', ' World!']

请使用我们的字符串方法参考手册，学习更多的字符串方法。

7.9 检查字符串

如需检查字符串中是否存在特定短语或字符，我们可以使用 in 或 not in 关键字。

实例
检查以下文本中是否存在短语 “ina”：

txt = "China is a great country"
x = "ina" in txt
print(x)

实例
检查以下文本中是否没有短语 “ina”：

txt = "China is a great country"
x = "ain" not in txt
print(x) 

7.10 字符串级联（串联）

如需串联或组合两个字符串，您可以使用 + 运算符。

实例
将变量 a 与变量 b 合并到变量 c 中：

a = "Hello"
b = "World"
c = a + b
print(c)

实例
在它们之间添加一个空格：

a = "Hello"
b = "World"
c = a + " " + b
print(c)

7.11 字符串格式

正如在 Python 变量一章中所学到的，我们不能像这样组合字符串和数字：

实例

age = 63
txt = "My name is Bill, I am " + age
print(txt)

但是我们可以使用 format() 方法组合字符串和数字！

format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：

实例
使用 format() 方法将数字插入字符串：

age = 63 
txt = "My name is Bill, and I am {}"
print(txt.format(age))

format() 方法接受不限数量的参数，并放在各自的占位符中：

实例

quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))

您可以使用索引号 {0} 来确保参数被放在正确的占位符中：

实例

quantity = 3
itemno = 567
price = 49.95
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))

7.12 方法表

8. 运算符

8.1 算术运算符

8.2 赋值运算符

8.3 比较运算符

8.4 逻辑运算符

8.5 身份运算符

8.6 成员运算符

8.7 位运算符

9. 列表

9.1 概述

Python 编程语言中有四种集合数据类型：

• 列表（List）是一种有序和可更改的集合。允许重复的成员。
• 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
• 集合（Set）是一个无序和无索引的集合。没有重复的成员。
• 词典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。
  列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写。
  代码演示

thislist = ["apple", "banana", "cherry"]
print(thislist)

9.2 访问项目

您可以通过引用索引号来访问列表项：

实例
打印列表的第二项：

thislist = ["apple", "banana", "cherry"]
print(thislist[1])

9.3 负的索引

负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目，依此类推。

实例
打印列表的最后一项：

thislist = ["apple", "banana", "cherry"]
print(thislist[-1])

9.4 索引范围

您可以通过指定范围的起点和终点来指定索引范围。

指定范围后，返回值将是包含指定项目的新列表。

实例
返回第三、第四、第五项：

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])

9.5 负索引的范围

如果要从列表末尾开始搜索，请指定负索引：

实例
此例将返回从索引 -4（包括）到索引 -1（排除）的项目：

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[-4:-1])

9.6 更改项目值

如需更改特定项目的值，请引用索引号：

实例
更改第二项：

thislist = ["apple", "banana", "cherry"]
thislist[1] = "mango"
print(thislist)

9.7 遍历列表

您可以使用 for 循环遍历列表项：

实例
逐个打印列表中的所有项目：

thislist = ["apple", "banana", "cherry"]
for x in thislist:
  print(x)

9.8 检查项目是否存在

如需确定列表中是否存在指定的项，请使用 in 关键字：

实例
检查列表中是否存在 “apple”：

thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
  print("Yes, 'apple' is in the fruits list")

9.9 列表长度

如需确定列表中有多少项，请使用 len() 方法：

实例
打印列表中的项目数：

thislist = ["apple", "banana", "cherry"]
print(len(thislist))

9.10 添加项目

如需将项目添加到列表的末尾，请使用 append() 方法：

实例
使用 append() 方法追加项目：

thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)

要在指定的索引处添加项目，请使用 insert() 方法：

实例
插入项目作为第二个位置：

thislist = ["apple", "banana", "cherry"]
thislist.insert(1, "orange")
print(thislist)

9.11 删除项目

有几种方法可以从列表中删除项目：

实例
remove() 方法删除指定的项目：

thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)

pop() 方法删除指定的索引（如果未指定索引，则删除最后一项）：

thislist = ["apple", "banana", "cherry"]
thislist.pop()
print(thislist)

del 关键字删除指定的索引：

thislist = ["apple", "banana", "cherry"]
del thislist[0]
print(thislist)

clear() 方法清空列表：

thislist = [“apple”, “banana”, “cherry”]
thislist.clear()
print(thislist)

9.12 复制列表

您只能通过键入 list2 = list1 来复制列表，因为：list2 将只是对 list1 的引用，list1 中所做的更改也将自动在 list2 中进行。

有一些方法可以进行复制，一种方法是使用内置的 List 方法 copy()。

实例
使用 copy() 方法来复制列表：

thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)

制作副本的另一种方法是使用内建的方法 list()。

实例
使用 list() 方法复制列表：

thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)

9.13 合并两个列表

在 Python 中，有几种方法可以连接或串联两个或多个列表。

最简单的方法之一是使用 + 运算符。

实例
合并两个列表：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list3 = list1 + list2
print(list3)

连接两个列表的另一种方法是将 list2 中的所有项一个接一个地追加到 list1 中：

实例
把 list2 追加到 list1 中：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

for x in list2:
  list1.append(x)

print(list1)

或者，您可以使用 extend() 方法，其目的是将一个列表中的元素添加到另一列表中：

实例
使用 extend() 方法将 list2 添加到 list1 的末尾：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list1.extend(list2)
print(list1)

9.14 list() 构造函数

也可以使用 list() 构造函数创建一个新列表。

实例
使用 list() 构造函数创建列表：

thislist = list(("apple", "banana", "cherry")) # 请注意双括号
print(thislist)

9.15 列表生成式

#九九乘法表

[(print(str(i)+'*'+str(j)+'='+str(i*j)+('\n'if i==j else' '),end=" ") )for i in range(1,10) for j in range(1,i+1)]

11. 元组

11.1 元组（Tuple）

元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。

实例

11.2 创建元组：

thistuple = ("apple", "banana", "cherry")
print(thistuple)

11.3 访问元组项目

您可以通过引用方括号内的索引号来访问元组项目：

实例
打印元组中的第二个项目：

thistuple = ("apple", "banana", "cherry")
print(thistuple[1])

11.4 负索引

负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目，依此类推。

实例
打印元组的最后一个项目：

thistuple = ("apple", "banana", "cherry")
print(thistuple[-1])

11.5 索引范围

您可以通过指定范围的起点和终点来指定索引范围。

指定范围后，返回值将是带有指定项目的新元组。

实例
返回第三、第四、第五个项目：

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])

注释：搜索将从索引 2（包括）开始，到索引 5（不包括）结束。

请记住，第一项的索引为 0。

11.6 负索引范围

如果要从元组的末尾开始搜索，请指定负索引：

实例
此例将返回从索引 -4（包括）到索引 -1（排除）的项目：

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[-4:-1])

11.7 更改元组值

创建元组后，您将无法更改其值。元组是不可变的，或者也称为恒定的。

但是有一种解决方法。您可以将元组转换为列表，更改列表，然后将列表转换回元组。

实例
把元组转换为列表即可进行更改：

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

11.8 遍历元组

您可以使用 for 循环遍历元组项目。

实例
遍历项目并打印值：

thistuple = ("apple", "banana", "cherry")
for x in thistuple:
  print(x)

您将在 Python For 循环 这一章中学习有关 for 循环的更多知识。

检查项目是否存在
要确定元组中是否存在指定的项，请使用 in 关键字：

实例
检查元组中是否存在 “apple”：

thistuple = ("apple", "banana", "cherry")
if "apple" in thistuple:
  print("Yes, 'apple' is in the fruits tuple")

11.9 元组长度

要确定元组有多少项，请使用 len() 方法：

实例
打印元组中的项目数量：

thistuple = ("apple", "banana", "cherry")
print(len(thistuple))

11.10 添加项目

元组一旦创建，您就无法向其添加项目。元组是不可改变的。

实例
您无法向元组添加项目：

thistuple = ("apple", "banana", "cherry")
thistuple[3] = "orange" # 会引发错误
print(thistuple)

11.11 创建有一个项目的元组

如需创建仅包含一个项目的元组，您必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组。

实例
单项元组，别忘了逗号：

thistuple = ("apple",)
print(type(thistuple))

#不是元组
thistuple = ("apple")
print(type(thistuple))

11.12 删除项目

注释：您无法删除元组中的项目。

元组是不可更改的，因此您无法从中删除项目，但您可以完全删除元组：

实例

del 关键字可以完全删除元组：

thistuple = ("apple", "banana", "cherry")
del thistuple

print(thistuple) # 这会引发错误，因为元组已不存在。

11.13 合并两个元组

如需连接两个或多个元组，您可以使用 + 运算符：

实例
合并这个元组：

tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)

11.14 tuple() 构造函数

也可以使用 tuple() 构造函数来创建元组。

实例
使用 tuple() 方法来创建元组：

thistuple = tuple(("apple", "banana", "cherry")) # 请注意双括号
print(thistuple)

11.15 方法

12. 集合

12.1 更改项目

集合一旦创建，您就无法更改项目，但是您可以添加新项目。

添加项目
要将一个项添加到集合，请使用 add() 方法。

要向集合中添加多个项目，请使用 update() 方法。

实例
使用 add() 方法向 set 添加项目：

thisset = {"apple", "banana", "cherry"}

thisset.add("orange")

print(thisset)

实例
使用 update() 方法将多个项添加到集合中：

thisset = {"apple", "banana", "cherry"}

thisset.update(["orange", "mango", "grapes"])

print(thisset)

12.2 获取 Set 的长度

要确定集合中有多少项，请使用 len() 方法。

实例
获取集合中的项目数：

thisset = {"apple", "banana", "cherry"}

print(len(thisset))

12.3 删除项目

要删除集合中的项目，请使用 remove() 或 discard() 方法。

实例
使用 remove() 方法来删除 “banana”：

thisset = {"apple", "banana", "cherry"}

thisset.remove("banana")


print(thisset)

注释：如果要删除的项目不存在，则 remove() 将引发错误。

实例
使用 discard() 方法来删除 “banana”：

thisset = {"apple", "banana", "cherry"}

thisset.discard("banana")

print(thisset)

注释：如果要删除的项目不存在，则 discard() 不会引发错误。

您还可以使用 pop() 方法删除项目，但此方法将删除最后一项。请记住，set 是无序的，因此您不会知道被删除的是什么项目。

pop() 方法的返回值是被删除的项目。

实例
使用 pop() 方法删除最后一项：

thisset = {"apple", "banana", "cherry"}

x = thisset.pop()

print(x)

print(thisset)

注释：集合是无序的，因此在使用 pop() 方法时，您不会知道删除的是哪个项目。

实例
clear() 方法清空集合：

thisset = {"apple", "banana", "cherry"}

thisset.clear()

print(thisset)

实例
del 彻底删除集合：

thisset = {"apple", "banana", "cherry"}

del thisset

print(thisset)

12.4 合并两个集合

在 Python 中，有几种方法可以连接两个或多个集合。

您可以使用 union() 方法返回包含两个集合中所有项目的新集合，也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中：

实例
union() 方法返回一个新集合，其中包含两个集合中的所有项目：

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

实例
update() 方法将 set2 中的项目插入 set1 中：

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set1.update(set2)
print(set1)

注释：union() 和 update() 都将排除任何重复项。

还有其他方法将两个集合连接起来，并且仅保留重复项，或者永远不保留重复项，请查看此页面底部的集合方法完整列表。

set() 构造函数
也可以使用 set() 构造函数来创建集合。

实例
使用 set() 构造函数来创建集合：

thisset = set((“apple”, “banana”, “cherry”)) # 请留意这个双括号
print(thisset)

12.5 Set 方法

Python 拥有一套能够在集合（set）上使用的内建方法。

13. 字典

13.1 字典（Dictionary）

字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

实例
创建并打印字典：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
print(thisdict)

13.2 访问项目

您可以通过在方括号内引用其键名来访问字典的项目：

实例
获取 “model” 键的值：

x = thisdict["model"]

还有一个名为 get() 的方法会给你相同的结果：

实例
获取 “model” 键的值：

x = thisdict.get("model")

13.3 更改值

您可以通过引用其键名来更改特定项的值：

实例
把 “year” 改为 2019：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict["year"] = 2019

13.4 遍历字典

您可以使用 for 循环遍历字典。

循环遍历字典时，返回值是字典的键，但也有返回值的方法。

实例
逐个打印字典中的所有键名：

for x in thisdict:
  print(x)

实例
逐个打印字典中的所有值：

for x in thisdict:
  print(thisdict[x])

实例
您还可以使用 values() 函数返回字典的值：

for x in thisdict.values():
  print(x)

实例
通过使用 items() 函数遍历键和值：

for x, y in thisdict.items():
  print(x, y)

13.5 检查键是否存在

要确定字典中是否存在指定的键，请使用 in 关键字：

实例
检查字典中是否存在 “model”：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
if "model" in thisdict:
  print("Yes, 'model' is one of the keys in the thisdict dictionary")

13.6 字典长度

要确定字典有多少项目（键值对），请使用 len() 方法。

实例
打印字典中的项目数：

print(len(thisdict))

13.7 添加项目

通过使用新的索引键并为其赋值，可以将项目添加到字典中：

实例

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict["color"] = "red"
print(thisdict)

13.8 删除项目

有几种方法可以从字典中删除项目：

实例
pop() 方法删除具有指定键名的项：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict.pop("model")
print(thisdict)

实例
popitem() 方法删除最后插入的项目（在 3.7 之前的版本中，删除随机项目）：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict.popitem()
print(thisdict)

实例
del 关键字删除具有指定键名的项目：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
del thisdict["model"]
print(thisdict)

实例
del 关键字也可以完全删除字典：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
del thisdict

print(thisdict) #this 会导致错误，因为 "thisdict" 不再存在。

实例
clear() 关键字清空字典：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict.clear()
print(thisdict)

13.9 复制字典

您不能通过键入 dict2 = dict1 来复制字典，因为：dict2 只是对 dict1 的引用，而 dict1 中的更改也将自动在 dict2 中进行。

有一些方法可以进行复制，一种方法是使用内建的字典方法 copy()。

实例
使用 copy() 方法来复制字典：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
mydict = thisdict.copy()
print(mydict)

制作副本的另一种方法是使用内建方法 dict()。

实例
使用 dict() 方法创建字典的副本：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
mydict = dict(thisdict)
print(mydict)

13.10 嵌套字典

词典也可以包含许多词典，这被称为嵌套词典。

实例
创建包含三个字典的字典：

myfamily = {
  "child1" : {
    "name" : "Phoebe Adele",
    "year" : 2002
  },
  "child2" : {
    "name" : "Jennifer Katharine",
    "year" : 1996
  },
  "child3" : {
    "name" : "Rory John",
    "year" : 1999
  }
}

或者，如果您想嵌套三个已经作为字典存在的字典：

实例
创建三个字典，然后创建一个包含其他三个字典的字典：

child1 = {
  "name" : "Phoebe Adele",
  "year" : 2002
}
child2 = {
  "name" : "Jennifer Katharine",
  "year" : 1996
}
child3 = {
  "name" : "Rory John",
  "year" : 1999
}

myfamily = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}

dict() 构造函数
也可以使用 dict() 构造函数创建新的字典：

实例

thisdict = dict(brand="Porsche", model="911", year=1963)
#请注意，关键字不是字符串字面量
#请注意，使用了等号而不是冒号来赋值
print(thisdict)

13.11 字典方法

Python 提供一组可以在字典上使用的内建方法。

13.12 列表到字典

#1、dict()
l1=[(1,'a'),(2,'b'),
    (3,'c'),(4,'d')]
d1=dict(l1)
print (d1)

#2、zip()
l1=[1,2,3,4]
l2=['a','b','c','d']
d1=zip(l1,l2)
print (d1)
print (dict(d1))

14. If

14.1 if判断语句

1， if判断语句基本格式:
           if 要判断的条件:
               条件成立时，要做的事情

if age = 30:
    print("我已经成年了")
#输出结果为：我已经成年了

14.2 比较(即关系，条件)运算符(下表)：

15. While 循环

15.1 while循环的格式:

               while 条件:
                   条件满足时，做的事情1
                   条件满足时，做的事情2
                   条件满足时，做的事情3
                   ...(省略)...
               实例：循环打印5次



i = 0
while i < 5:
    print("i = %d,当前是第%d次执行循环" % (i,i + 1))
    i+=1
     
'''
输出结果：
i = 0,当前是第1次执行循环
i = 1,当前是第2次执行循环
i = 2,当前是第3次执行循环
i = 3,当前是第4次执行循环
i = 4,当前是第5次执行循环

‘’’

15.2 死循环：

由于程序员的原因，忘记 在循环内部 修改循环的判断条件，导致循环持续执⾏，程序⽆法终⽌！

死循环实例：

while True:
    print('这是一个死循环')
     
'''
输出结果：
这是一个死循环
这是一个死循环
这是一个死循环
这是一个死循环


。。。

‘’’

15.3 while循环嵌套

1. while循环嵌套的格式:
               while 条件1:
                   条件1满足时，做的事情1
                   条件1满足时，做的事情2
                   条件1满足时，做的事情3
                   ...(省略)...
                   while 条件2:
                       条件2满足时，做的事情21
                       条件2满足时，做的事情22
                       条件2满足时，做的事情23
                       ...(省略)...
               实例：打印三角形：

i = 1
while i <= 5:
    j = 1
    while j <= i:
        print("*", end=" ")
        j += 1
    print()
 
    i += 1
     
'''
输出结果：
* 
* * 
* * * 
* * * * 
* * * * * 
'''

16. For循环

16.1 Python For 循环

for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。

这与其他编程语言中的 for 关键字不太相似，而是更像其他面向对象编程语言中的迭代器方法。

通过使用 for 循环，我们可以为列表、元组、集合中的每个项目等执行一组语句。

实例
打印 fruits 列表中的每种水果：

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

提示：for 循环不需要预先设置索引变量。

16.2 循环遍历字符串

甚至连字符串都是可迭代的对象，它们包含一系列的字符：

实例
循环遍历单词 “banana” 中的字母：

for x in "banana":
  print(x)

16.3 break 语句

通过使用 break 语句，我们可以在循环遍历所有项目之前停止循环：

实例
如果 x 是 “banana”，则退出循环：

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x) 
  if x == "banana":
    break

实例
当 x 为 “banana” 时退出循环，但这次在打印之前中断：

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    break
  print(x)

16.4 continue 语句

通过使用 continue 语句，我们可以停止循环的当前迭代，并继续下一个：

实例
不打印香蕉：

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    continue
  print(x)

16.5 range() 函数

如需循环一组代码指定的次数，我们可以使用 range() 函数，

range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。

实例
使用 range() 函数：

for x in range(10):
print(x)

注意：range(10) 不是 0 到 10 的值，而是值 0 到 9。

range() 函数默认 0 为起始值，不过可以通过添加参数来指定起始值：range(3, 10)，这意味着值为 3 到 10（但不包括 10）：

实例
使用起始参数：

for x in range(3, 10):
  print(x)

range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：range(2, 30, 3)：

实例
使用 3 递增序列（默认值为 1）：

for x in range(3, 50, 6):
  print(x)

16.6 For 循环中的 Else

for 循环中的 else 关键字指定循环结束时要执行的代码块：

实例
打印 0 到 9 的所有数字，并在循环结束时打印一条消息：

for x in range(10):
  print(x)
else:
  print("Finally finished!")

16.7 嵌套循环

嵌套循环是循环内的循环。

“外循环”每迭代一次，“内循环”将执行一次：

实例
打印每个水果的每个形容词：

adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]

for x in adj:
  for y in fruits:
    print(x, y)

16.8 pass 语句

for 语句不能为空，但是如果您处于某种原因写了无内容的 for 语句，请使用 pass 语句来避免错误。

实例

for x in [0, 1, 2]:
  pass

17. 函数

17.1 创建函数

在 Python 中，使用 def 关键字定义函数：

实例

def my_function():
  print("Hello from a function")

17.2 调用函数

如需调用函数，请使用函数名称后跟括号：

实例

def my_function():
  print("Hello from a function")

my_function()

17.3 参数

信息可以作为参数传递给函数。

参数在函数名后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。

下面的例子有一个带参数（fname）的函数。当调用此函数时，我们传递一个名字，在函数内部使用它来打印全名：

实例

def my_function(fname):
  print(fname + " Gates")

my_function("Bill")
my_function("Steve")
my_function("Elon")

17.4 默认参数值

下面的例子展示如何使用默认参数值。

如果我们调用了不带参数的函数，则使用默认值：

实例

def my_function(country = "China"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

17.5 以 List 传参

您发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型。

例如，如果您将 List 作为参数发送，它到达函数时仍将是 List（列表）：

实例

def my_function(food):
  for x in food:
    print(x)

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

my_function(fruits)

17.6 返回值

如需使函数返回值，请使用 return 语句：

实例

def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))

17.7 关键字参数

您还可以使用 key = value 语法发送参数。

参数的顺序无关紧要。

实例

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")

在 Python 文档中，“关键字参数”一词通常简称为 kwargs。

17.8 任意参数

如果您不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *。

这样，函数将接收一个参数元组，并可以相应地访问各项：

实例
如果参数数目未知，请在参数名称前添加 *：

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Phoebe", "Jennifer", "Rory")

17.9 pass 语句

函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误。

实例

def myfunction:
  pass

17.10 递归

Python 也接受函数递归，这意味着定义的函数能够调用自身。

递归是一种常见的数学和编程概念。它意味着函数调用自身。这样做的好处是可以循环访问数据以达成结果。

开发人员应该非常小心递归，因为它可以很容易地编写一个永不终止的，或者使用过量内存或处理器能力的函数。但是，在被正确编写后，递归可能是一种非常有效且数学上优雅的编程方法。

在这个例子中，tri_recursion() 是我们定义为调用自身 (“recurse”) 的函数。我们使用 k 变量作为数据，每次递归时递减（-1）。当条件不大于 0 时（比如当它为 0 时），递归结束。

对于新的开发人员来说，可能需要一些时间来搞清楚其工作原理，最好的方法是测试并修改它。

实例
递归的例子：

def tri_recursion(k):
  if(k>0):
    result = k+tri_recursion(k-1)
    print(result)
  else:
    result = 0
  return result

print("\n\nRecursion Example Results")
tri_recursion(6)

18. Lambda

18.1 语法

lambda arguments : expression
执行表达式并返回结果：

实例
一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果：

x = lambda a : a + 10
print(x(5))

18.2 lambda 函数可接受任意数量的参数：

实例
一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果：

x = lambda a, b : a * b
print(x(5, 6))

实例
一个 lambda 函数，它把参数 a、b 和 c 相加并打印结果：

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

为何使用 Lambda 函数？
当您把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。

假设您有一个带一个参数的函数定义，并且该参数将乘以未知数字：

def myfunc(n):
  return lambda a : a * n

使用该函数定义来创建一个总是使所发送数字加倍的函数：

实例

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))

或者，使用相同的函数定义来创建一个总是使您发送的数字增加三倍的函数：

实例

def myfunc(n):
  return lambda a : a * n

mytripler = myfunc(3)

print(mytripler(11))

运行实例
或者，在同一程序中使用相同的函数定义来生成两个函数：

实例

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11)) 
print(mytripler(11))

19. 数组