python基础知识点

Python注释

1.单行注释

将需要注释的部分开头用# 例如：

#srgsgsfg
print('124342')

2.多行注释

左键选中我们需要注释的代码，松开，按：Ctrl+/，就完成相同效果注释。第二种方法：把要注释的内容放到三个引号对里面。，例如：

取消注释 左键选中我们需要取消注释的代码，松开，按：Ctrl+/

Python 变量

在 Python 中，当你给它赋值时就会创建变量：Python 没有用于声明变量的命令。变量在您第一次为其赋值时创建。例如：

对于同一个变量，赋值类型不同则会发生类型的变化，例如：

x = 4       # x 现在是整形
x = "川川" # x 现在是字符串
print(x)

如果要指定变量的数据类型，可以通过强制转换来完成，比如：

x = str(3)    # x will be '3'
y = int(3)    # y will be 3
z = float(3)  # z will be 3.0

如何获取类型，这里我们要用到type函数，举个例子：

变量名命名

变量名区分大小写

骆驼法则：除了第一个单词外，每个单词都以大写字母开头

帕斯卡法则：每个单词都以大写字母开头

蛇形法则：每个单词由下划线字符分隔

分配多个值

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

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

打开一个集合

如果您在列表、元组等中有一组值。Python 允许您将值提取到变量中。这称为拆包。

fruits = ["apple", "banana", "cherry"]
x, y, z = fruits
print(x)
print(y)
print(z)

输出变量

print语句通常用于输出变量。为了组合文本和变量，Python 使用 +字符：

可以使用该+字符将一个变量添加到另一个变量中：

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

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

如果你尝试组合一个字符串和一个数字，Python 会给你一个错误该怎么修改呢？把数字转为字符即可

全局变量与局部变量，全局关键字

在函数外部创建的变量称为全局变量。都可以使用全局变量，无论是在函数内部还是外部。

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

全局关键字 通常，当您在函数内部创建变量时，该变量是局部的，并且只能在该函数内部使用。要在函数内创建全局变量，可以使用 global关键字。

Python数据类型

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

文本类型：	str
数字类型：	int, float, complex
序列类型：	list, tuple, range
映射类型：	dict
套装类型：	set, frozenset
布尔类型：	bool
二进制类型：	bytes, bytearray, memoryview

获取数据类型

您可使用以下type()函数获取任何对象的数据类型。例如，打印变量 x 的数据类型：

x = 6
print(type(x))

list列表类型：

x4 = ["apple", "banana", "cherry"]
print(x4)
print(type(x4))

tuple元祖类型：

x5 = ("apple", "banana", "cherry")
print(x5)
print(type(x5))

随机数

Python 有一个内置模块 random可以用来生成随机数。示例：导入 random 模块，并显示 1 到 10之间的一个随机数：

import random
print(random.randrange(1, 11))

多行字符串

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

a = """从前有座山，
山里有座庙
庙里有个小和尚"""
print(a)

字符串是数组

Python 没有字符数据类型，单个字符只是一个长度为 1 的字符串。方括号可用于访问字符串的元素。这里用到了切片，你可以不懂。获取位置 1 处的字符（记住第一个字符的位置为 0）：

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

遍历字符串

循环遍历单词“chuanchuan”中的字母：

for x in "chuanchuan":
  print(x)

字符串长度

len()函数返回字符串的长度，注意标点符号和空格也算一个长度：

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

检查字符串

要检查字符串中是否存在某个短语或字符，我们可以使用关键字 in。

txt = "The best things in life are free!"
print("free" in txt)

切片字符串

1.切片

您可以使用切片语法返回一系列字符。指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。第一个字符的索引为 0。

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

2.从头开始切片

获取从开始到位置 5 的字符（不包括在内）：

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

切到最后

通过省略结束索引，范围将到最后。例如，获取从位置 2 到最后的字符：

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

负索引

使用负索引从字符串末尾开始切片，就是从右往左看，不再是从左往右看。例如：

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

修改字符串

1.小写转大写

upper()方法以大写形式返回字符串：

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

2.大写转小写

lower()方法以小写形式返回字符串：

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

3.删除空格

空白是实际文本之前和/或之后的空间，通常您想删除这个空间。strip()方法从开头或结尾删除任何空格：

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

4.替换字符串

replace()方法用另一个字符串替换一个字符串.

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

拆分字符串

split()方法返回一个列表，其中指定分隔符之间的文本成为列表项。split()如果找到分隔符的实例，该方法会将字符串拆分为子字符串。例如我要将下面的字符串以逗号分隔：

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

字符串连接

要连接或组合两个字符串，您可以使用 + 运算符。例如，将变量a与变量b, 合并到变量中c：

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

格式化字符串

1.format单个传参

format()方法接受传递的参数，格式化它们，并将它们放在占位符所在的字符串中 {}。例如，使用format()方法将数字插入字符串:

2.format多个个传参

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

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

字符串的其它处理方法总结

1. capitalize() 将第一个字符转换为大写
2. casefold() 将字符串转换为小写
3. center() 返回一个居中的字符串
4. count() 返回指定值在字符串中出现的次数
5. encode() 返回字符串的编码版本
6. endswith() 如果字符串以指定的值结尾，则返回 true
7. join() 将可迭代的元素连接到字符串的末尾
8. find() 在字符串中搜索指定值并返回找到它的位置
9. format() 初始化字符串中的指定值
10. 10.index() 在字符串中搜索指定值并返回找到它的位置

布尔真值

True如果它具有某种内容，几乎任何值都会被评估。任何字符串都是True，空字符串除外。任何数字都是True，除了 0。任何列表、元组、集合和字典都是True，空的除外。

布尔假值

False除了空值（例如()、 []、{}、 ""、 数字 0和 值 ）之外，计算为 的值 None。当然，结果为 False。

Python列表

基本形式为：

1.创建列表

列表是使用方括号创建的：

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

thislist = list(("apple", "banana", "cherry"))
print(thislist)

允许重复 由于列表已编入索引，因此列表可以包含具有相同值的项目：

2.列出表值

列表项是有序的、可变的，并允许重复值。列表项被索引，第一项有索引[0]，第二项有索引[1]等等。 单个索引 例如我要索取川川一号：

3.列表长度

确定列表有多少项，请使用以下 len()函数：

4.列表项 - 数据类型

列表项可以是任何数据类型。例如：

5.Python 集合（数组）

1. List列表是一个有序且可变的集合。允许重复成员。
2. turple元组是一个有序且不可更改的集合。允许重复成员。
3. Set集合是一个无序且无索引的集合。没有重复的成员。
4. dict字典是一个有序*且可变的集合。没有重复的成员。！！！从 Python 3.7 版开始，字典才是有序的！！！

访问列表

1.正常索引

列表项已编入索引，您可以通过引用索引号来访问它们：

注意：第一项的索引为 0。

2.负索引

负索引意味着从头开始，-1指最后一项， -2指倒数第二项等。

3.索引范围

4.负指数范围

5.检查是否存在

要确定列表中是否存在指定的项目，请使用in关键字。例如，检查列表中是否存在“apple”：

.更改列表

1.单个更改

要更改特定位置的值，需要通过索引号：

2.多个更改

索引号需要用范围表示。

3.插入列表

insert()方法在指定的索引处插入一个项目。

添加列表

1.末尾添加

要将值添加到列表的末尾，请使用append() 方法：

2.指定位置添加

3.合并列表

要将另一个列表中的元素附加到当前列表，请使用extend()方法。extend()方法不一定要 列表，您也可以添加任何可迭代对象（元组、集合、字典等）。

删除列表

1.删除指定目标

remove()方法删除指定的项目。

2.删除指定索引

pop()方法删除指定的索引。

如果不指定索引，该pop()方法将删除最后一项。

3.del删除指定的索引

该del关键字也可以完全删除列表。

4.清除列表

clear()方法清空列表。该列表仍然存在，但没有内容。

循环列表

1.for循环遍历

方法一：循环遍历列表您可以使用循环遍历列表项for 。

二：遍历索引号

2.while循环遍历

.列表推导式

列表排序

1.区分大小写的排序

默认情况下，该sort()方法区分大小写，导致所有大写字母都排在小写字母之前：

thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort()
print(thislist)

2.不区分大小写的排序

如果你想要一个不区分大小写的排序函数，使用 str.lower 作为键函数：

thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort(key = str.lower)
print(thislist)

3.倒序

reverse()方法反转元素的当前排序顺序。

复制列表

copy()方法制作列表的副本：

list()方法制作列表的副本：

加入列表

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

list1 = ["a", "b", "c"]
list2 = [1, 2, 3]
list3 = list1 + list2
print(list3)

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

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

for x in list2:
  list1.append(x)

print(list1)

extend() 方法，其目的是将元素从一个列表添加到另一个列表：

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

list1.extend(list2)
print(list1)

Python元组

元组用于在单个变量中存储多个项目。Tuple 是 Python 中用于存储数据集合的 4 种内置数据类型之一，其他 3 种是List、 Set和Dictionary。元组项是有序的、不可更改的，并允许重复值。元组项被索引，第一项被索引[0]，第二项被索引[1]等

1.2元组长度

我们还是跟列表一样，用到len函数，例子如下：

一项元组，记住逗号，不然就不是元祖了！我将两个形式读写出来，可以做一个对比：

1.3数据类型

元组项可以是任何数据类型：字符串、整数和布尔数据类型.

元组可以包含不同的数据类型。包含字符串、整数和布尔值的元组，形式如下：

使用tuple()来创建元组，形式如下：

访问元组

2.1正常访问

您可以通过引用方括号内的索引号来访问元组项，比如打印第二项：

注意：第一项的索引为 0。

2.2负索引

负索引意味着从头开始。-1指最后一项， -2指倒数第二项等。例如打印元组的最后一项：

2.3范围性索引

您可以通过指定范围的开始和结束位置来指定索引范围。指定范围时，返回值将是具有指定项的新元组。这里我们用到range函数，前面讲过。返回第三、第四和第五项：

注意：搜索将从索引 2（包括）开始并在索引 5（不包括）处结束。请记住，第一项的索引为 0。

通过省略起始值，范围将从第一项开始（自己打印看看）：

通过省略结束值，范围将继续到列表的末尾：

负数范围

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

.更新元组

元组是不可更改的，这意味着一旦创建了元组，您就无法更改、添加或删除项目。但是有一些解决方法：将元组转换为列表，更改列表，然后将列表转换回元组。

3.1替换

比如我要将下面第二个元素改为帅哥：

3.2添加项目值

由于元组是不可变的，它们没有内置 append()方法，但有其他方法可以向元组添加项。 方法1:转换为列表：就像更改元组的解决方法一样，您可以将其转换为列表，添加您的项目，然后将其转换回元组。例如：将元组转换为列表，添加“爱你”，然后将其转换回元组：

方法2：将元组添加到元组。您可以向元组添加元组，因此如果您想添加一个（或多个）项目，请使用该项目创建一个新元组，并将其添加到现有元组中。注意：创建只有一个item的元组时，记得在item后面加上逗号，否则不会被识别为元组。

3.3删除项目

注意：您不能删除元组中的项目。元组是不可更改的，因此您无法从中删除项目，但您可以使用与我们用于更改和添加元组项目相同的解决方法：

示例 将元组转换为列表，删除“apple”，然后将其转换回元组：

或者您可以完全删除元组：该del关键字可以完全删除的元组

this = ("川川菜鸟", "川川二号", "川川三号",'川川一号')
del this
print(this)

解包元组

当我们创建一个元组时，我们通常会为其分配值。这称为“打包”元组。包装元组：

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

但是，在 Python 中，我们也可以将值提取回变量中。这称为“解包”。解包元组：

fruits = ("apple", "banana", "cherry")
(green, yellow, red) = fruits
print(green)
print(yellow)
print(red)

使用星号* 如果变量的数量少于值的数量，您可以*在变量名中添加一个，值将作为列表分配给变量。将其余值分配为名为“red”的列表：

fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")
(green, yellow, *red) = fruits
print(green)
print(yellow)
print(red)

如果星号被添加到另一个变量名而不是最后一个，Python 将为变量赋值，直到剩余的值数量与剩余的变量数量匹配。添加值列表“tropic”变量：

fruits = ("apple", "mango", "papaya", "pineapple", "cherry")

(green, *tropic, red) = fruits

print(green)
print(tropic)
print(red)

五.循环元祖

5.1遍历元祖

也就是遍历元组的意思，只要我们提到遍历，那就是for循环。 方法一：直接遍历 例子如下：遍历项目并打印值

方法二： 遍历索引号 使用range()和len()函数创建合适的可迭代对象。

5.2使用 While 循环

六.元组合并

合并两个元祖，我们用+连接即可。

如果要将元组的内容乘以给定次数，可以使用* 运算符：

count函数用于返回指定值次数：查找5出现次数

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
x = thistuple.count(5)
print(x)

index()找出指定值并返回它的位置：查找元祖中8位置

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
x = thistuple.index(8)
print(x)

Python集合

一.集合理解

基本形式：

集合是用大括号写的。创建一个集合：

集合是无序的，因此您无法确定项目的显示顺序。

二.访问集合

2.1遍历集合

您不能通过引用索引或键来访问集合中的项目。但是您可以使用循环遍历集合项for ，或者使用in关键字询问集合中是否存在指定的值 。例如：

3.2检查是否存在

检查集合中是否存在“串串一号”：（显然不在）

三.添加集合

3.1添加项目值

创建集合后，您无法更改其项目，但可以添加新项目。要将一项添加到集合中，请使用add() 方法。例如：添加川川菜鸟到集合中

3.2添加集合

要将另一个集合中的项目添加到当前集合中，请使用update() 方法。例如将myset1添加到myset中：

为什么?别忘了我们的集合不能重复，重复的集合会被覆盖，因此只添加了新的值进来。

3.3添加任何可迭代对象

update()方法中的对象不一定是集合，它可以是任何可迭代对象（元组、列表、字典等）。例如：将myset2列表加入集合myset1

四.移除集合项

4.1remove方法

要删除集合中的项目，请使用remove()、 或discard()方法。例如我要移除川川菜鸟：

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

4.2discard() 方法

使用以下discard() 方法删除“川川菜鸟” ：

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

4.3pop() 方法

使用以下pop() 方法删除最后一项：

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

4.4clear() 方法

clear() 方法清空集合：

打印为空。

4.5del关键字

该del关键字将完全删除该集合：

五.循环集合

for循环遍历即可

六.集合连接

6.1普通连接

您可以使用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() 将排除任何重复的项目。

6.2仅保留重复项

intersection_update()方法将只保留两个集合中都存在的项目。保留myset4和myset5重复项：

或者用intersection()方法将返回一个新集合，该集合仅包含两个集合中都存在的项目。

6.3保留所有，但不保留重复项

symmetric_difference_update()方法将只保留两个集合中都不存在的元素。

symmetric_difference()方法将返回一个新集合，该集合仅包含两个集合中都不存在的元素。

Python字典

一.字典理解

基本形式：

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

字典用于在键值对中存储数据值。字典是有序*、可变且不允许重复的集合。（从 Python 3.7 版开始，字典是有序的。在 Python 3.6 及更早版本中，字典是无序的。）

1.1创建字典与访问

字典是用大括号写的，有键和值。创建并打印字典：

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)

字典项是有序的、可变的，并且不允许重复。字典项以键值对的形式呈现，可以使用键名进行引用。例如打印brand的值

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict["brand"])

字典不能有两个具有相同键的项目：重复值将覆盖现有值 返回：

https://mmbiz.qpic.cn/mmbiz_png/Jy3qP5tic4icRoFMS0zvLPlRL8WeaI1n6Mg0rLdj45oayI92Yauia4ZHmxz9Ia2ykQkNK67lv4Gy9FzW17UXqwPCA/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1

1.2字典长度

还是用用len函数

hisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "year": 2020
}
print(len(thisdict))

1.3数据类型

字典项中的值可以是任何数据类型：例如：

thisdict = {
  "brand": "Ford",
  "electric": False,
  "year": 1964,
  "colors": ["red", "white", "blue"]
}

类型：dict() 打印字典的数据类型：

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(type(thisdict))

二.访问字典

2.1访问键名

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

还有一个被调用的方法get()会给你同样的结果：

2.2访问健值

keys()方法将返回字典中所有键的列表。

向原始字典添加一个新项目，并看到键列表也得到更新：

获取值 values()方法将返回字典中所有值的列表。

x = thisdict.values()

items()方法将返回字典中的每个项目，作为列表中的元组。

返回元祖：

https://mmbiz.qpic.cn/mmbiz_png/Jy3qP5tic4icRoFMS0zvLPlRL8WeaI1n6MbYINHkuPmKhsJslUHcBvbKsTwkMkxia2ibtFq8DyYDM96PaibdD6ZhP2A/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1

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

三.更改字典各种方法

前面我们讲到了一部分更改内容，这里我们具体讲一下。例如我要把川川改为川川菜鸟：

或者我们使用update()方法：

五.删除字典的各种方法

pop()方法删除具有指定键名的项。比如我要删除地址项目：

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

del关键字删除与指定键名称的项目：

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

del thisdict

clear()方法清空字典：

六.遍历字典

将字典中的所有键名，一一打印出来：

一一打印字典中的所有值：

您还可以使用该values()方法返回字典的值：

您可以使用该keys()方法返回字典的键：

七.复制字典

用copy()函数

内置dict(）函数

八.嵌套字典

创建一个包含三个字典的字典：

myfamily = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}
print(myfamily)

If ... Else语句

Python 支持数学中常见的逻辑条件：

• 等于：a == b
• 不等于：a != b
• 小于：a < b
• 小于或等于：a <= b
• 大于：a > b
• 大于或等于：a >= b

if语句 注意:if后面要有冒号

a = 33
b = 200
if b > a:
  print("b 大于 a")

缩进

Python 依靠缩进（行首的空格）来定义代码中的范围。为此，其他编程语言通常使用大括号。If 语句，没有缩进（会引发错误）：

elif语句

a = 33
b = 33
if b > a:
  print("b 大于 a")
elif a == b:
  print("a 等于b")

else语句

a = 200
b = 33
if b > a:
  print("b 大于 a")
elif a == b:
  print("a 等于b")
else:
  print("a 小于 b")

你也可以有一个else没有 elif

and语句

a = 200
b = 33
c = 500
if a > b and c > a:
  print("两种条件都满足")

or 语句

测试 if a是否大于 b，或 if a 大于c：

a = 200
b = 33
c = 500
if a > b or a > c:
  print("At least one of the conditions is True")

嵌套if语句

x = 41
if x > 10:
  print("Above ten,")
  if x > 20:
    print("and also above 20!")
  else:
    print("but not above 20.")

pass语句

if语句不能为空，但如果您出于某种原因有一个if没有内容，pass语句请放入该语句以避免出错。

a = 33
b = 200

if b > a:
  pass

while循环语句

使用while循环，只要条件为真，我们就可以执行一组语句。例如：只要 i 小于 6 就打印 i

i = 1
while i < 6:
  print(i)
  i += 1

中断声明

使用break语句，即使 while 条件为真，我们也可以停止循环：例如当 i 为 3 时退出循环：

i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  i += 1

使用break语句，即使 while 条件为真，我们也可以停止循环：例如当 i 为 3 时退出循环：

i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  i += 1

else 语句

使用else语句，当条件不再为真时，我们可以运行一次代码块：一旦条件为假，打印一条消息：

i = 1
while i < 6:
  print(i)
  i += 1
else:
  print("i is no longer less than 6")

for循环语句

基本遍历

使用for循环，我们可以执行一组语句，对列表、元组、集合等中的每个项目执行一次。例如：打印水果列表中的每个水果

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

遍历字符串

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

for x in "banana":
  print(x)

使用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)

continue 声明

使用continue语句，我们可以停止循环的当前迭代，并继续下一个：不要打印banana：

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

range() 函数

要循环一组代码指定的次数，我们可以使用range()函数，的范围（）函数返回由1个数字，通过默认从0开始，并递增的顺序（缺省），并结束在指定次数。例如：

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

返回：

https://mmbiz.qpic.cn/mmbiz_png/Jy3qP5tic4icRoFMS0zvLPlRL8WeaI1n6MibrxAc6hF07phJowtnhGwr41cNESicQvgqoOLcaauhNOxy6nMicqVeBJw/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1

注意

range(6)不是 0 到 6 的值，而是 0 到 5 的值。range函数默认被1至递增序列，但是有可能通过增加第三参数指定增量值：range（2，30，3）

嵌套循环

嵌套循环是循环内的循环。“内循环”将在“外循环”的每次迭代中执行一次。为每个fruits打印每个形容词：

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

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

pass语句

for循环不能为空，但如果由于某种原因有一个for没有内容的循环，请放入pass语句以避免出错。

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

lambda

lambda 函数是一个小的匿名函数。一个 lambda 函数可以接受任意数量的参数，但只能有一个表达式。语法： lambda arguments : expression 执行表达式并返回结果：

示例将 10 添加到 argument a，并返回结果：

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

Lambda 函数可以接受任意数量的参数。例将参数a与参数 相乘b并返回结果：

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

Python类和对象

创建类

要创建一个类，请使用关键字class。例如：创建一个名为 MyClass 的类，其属性名为 x

class MyClass:
  x = 5
print(MyClass)

创建对象

现在我们可以使用名为 MyClass 的类来创建对象。例如创建一个名为 p1 的对象，并打印 x 的值：

class MyClass:
  x = 5
p1 = MyClass()
print(p1.x)

**init() 函数

上面的例子是最简单形式的类和对象，在现实生活应用程序中并没有真正有用。要理解类的含义，我们必须了解内置的 init() 函数。所有类都有一个名为 init() 的函数，它总是在类被初始化时执行。使用 init() 函数为对象属性赋值，或在创建对象时需要执行的其他操作。

例如创建一个名为 Person 的类，使用 init() 函数为 name 和 age 赋值：

注意：init()每次使用该类创建新对象时都会自动调用该函数。

对象方法

让我们在 Person 类中创建一个方法。例如插入一个打印问候语的函数，并在 p1 对象上执行它：

自参数

self参数是对类当前实例的引用，用于访问属于该类的变量。它不必命名self，您可以随意调用它，但它必须是类中任何函数的第一个参数：

对象及其属性更改

替换 例如修改年龄为21

删除对象属性 例如从 p1 对象中删除 age 属性：

lass Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):
    print("Hello my name is " + self.name)
p1 = Person("John", 36)
del p1.age
print(p1.age)#没有了自然打印报错

Python继承

创建父类

任何类都可以是父类，因此语法与创建任何其他类相同：这里创建一个名为Person、 firstname和lastname属性的类，以及一个printname方法：

创建子类

创建从另一个类继承功能的类，请在创建子类时将父类作为参数发送。例如：创建一个名为 的类Student，它将继承该类的属性和方法Person

class Student(Person):
  pass

添加 init() 函数

到目前为止，我们已经创建了一个继承父类的属性和方法的子类。我们想将__init__()函数添加到子类（而不是pass关键字）。 注意：init()每次使用该类创建新对象时都会自动调用该函数。例如：将__init__()函数添加到 Student类中

class Student(Person):
  def __init__(self, fname, lname):

添加__init__()函数后，子类将不再继承父类的__init__()函数。注：孩子的__init__() 功能覆盖父母的继承 init()功能。为了保持父__init__() 函数的继承，添加对父函数的调用__init__()：

添加方法

添加一个调用welcome到 Student类的方法：

Python日期

日期输入输出

导入 datetime 模块并显示当前日期：

import datetime

x = datetime.datetime.now()
print(x)

工作日的年份和名称：

import datetime

x = datetime.datetime.now()

print(x.year)
print(x.strftime("%A"))

返回：

https://mmbiz.qpic.cn/mmbiz_png/Jy3qP5tic4icRoFMS0zvLPlRL8WeaI1n6MwVabTBlJ2z4tPuu6cOxQiclHXI5R4BOAiaAibwpGcZKyeAxbcvzEJDE2A/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1

Python JSON

JSON 是一种用于存储和交换数据的语法。JSON 是文本，用 JavaScript 对象表示法编写。Python 有一个名为 的内置包json，可用于处理 JSON 数据。导入 json 模块：

import json

从 JSON 转换为 Python

如果您有 JSON 字符串，则可以使用json.loads()方法对其进行解析 。结果将是一个Python 字典。例如：

如果您有 Python 对象，则可以使用json.dumps()方法将其转换为 JSON 字符串。

import json
# x为字典
x = {
  "name": "John",
  "age": 30,
  "city": "New York"
}
# 转为json
y = json.dumps(x)
# 结果为json字符串
print(y)
print(type(y))