python基础学习

Python是一种跨平台的编程语言，这意味着它可以在Windows，MacOS，Linux等多种平台上运行，甚至已经移植到Java和.NET虚拟机。它是免费和开源的。

即使当今的大多数Linux和Mac已经预装了Python，但该版本可能已过时。因此，安装最新版本始终是一个好主意。

说明：作者根据https://cainiaoplus.com/进行学习

下面学习过程我直接用linux python 来编写了

Python 关键字和标识符

关键字是Python中的保留字。

我们不能将关键字用作 [变量名](https://cainiaoplus.com/python/python-variables-datatypes.html)，[函数](https://cainiaoplus.com/python/python-function.html)名或任何其他标识符。它们用于定义Python语言的语法和结构。

在Python中，关键字区分大小写。

Python 3.7中有 33 个关键字。该数字在一段时间内可能会略有变化。

所有关键字必须是小写的，其中 True，False 和 None 除外。下面列出了所有关键字。

False	await	else	import	pass
None	break	except	in	raise
True	class	finally	is	return
and	continue	for	lambda	try
as	def	from	nonlocal	while
assert	del	global	not	with
async	elif	if	or	yield

Python标识符

标识符是给诸如类，函数，变量等实体的名称。它有助于将一个实体与另一个实体区分开。

编写标识符的规则

1. 标识符可以是小写字母（a 至 z）或大写字母（A 至 Z）或数字（0 至 9）或下划线(_)的组合。myClass，var_1，var_name_1, print_this_to_screen 都是有效的。
2. 标识符不能以数字开头。1variable 是无效的，但 variable1 是有效的。
3. 关键字不能用作标识符。

要记住的事情

Python 是 区分大小写 的语言。这意味着 Variable 和 variable 是两个不同的变量。同时，也建议大家，在实际编程中，始终命名有意义的标识符。

虽然，c = 10 也是有效的。但是使用 count = 10 看起来会更有意义，并且即使您在经过一段长时间的间隔之后查看代码，也更容易弄清楚它的作用和它所代表的意义。

可以使用下划线分隔多个单词进行命名，例如：this_is_a_long_variable

python 语句

在Python中，语句的结尾用换行符标记。但是我们可以使一条语句扩展到具有多行连续字符（\）的多行。例如：

a = 1 + 2 + 3 + \
    4 + 5 + 6 + \
    7 + 8 + 9

这是显式的行继续。在Python中，在圆括号()，方括号[]和花括号{}中暗含换行符。例如，我们可以将上述多行语句实现为 []和{}也是如此

Python缩进

大多数编程语言（例如C，C ++，Java）都使用大括号{}来定义代码块。而Python使用缩进

代码块（函数的主体，循环的主体等）以缩进开始，以第一条未缩进的行结束。缩进量取决于您，但是在整个块中缩进量必须保持一致。

通常，四个空格用于缩进，并且优先于制表符。

缩进不正确将导致IndentationError。

直接推进到集合的字面量集

字面量集

有四种不同的字面量集合：列表字面量，元组字面量，字典字面量 和 集合字面量。

eg:

fruits=["apple", "banana" ,"orange"]#这是一个列表
numbers=(1,2,3)#这是一个元组
alphabets={"a:apple","b:banana","o:orange"}#这是一个字典
vowels={'a','e','i','o','u'}#这是一个集合
#这是是一些字面量集
print(fruits)
print(numbers)
print(alphabets)
print(vowels)

Python 列表（List）

在Python编程中，通过将所有项目（元素）放在方括号[]中并用逗号分隔来创建列表。

它可以具有任意数量的项目，并且它们可以具有不同的类型（整数，浮点数，字符串等）

# 空 list
my_list = []

# 整数list
my_list = [1, 2, 3]

# 具有混合数据类型的列表
my_list = [1, "Hello", 3.4]

同样，一个列表甚至可以将另一个列表作为项目。这称为嵌套列表。

# 嵌套 list
my_list = ["mouse", [8, 4, 6], ['a']]

访问列表中的元素

my_list =['G','0','u','f','3','n']
print(my_list[0])
print(my_list[2])
seconde_list =['s','s',"Gu0f3n"]
print(seconde_list[2][4])
#输出
#G
#u
#3

如何在Python中切片列表？

my_list = ['p','r','o','g','r','a','m','i','z']
# 从第3元素至第5个元素
print(my_list[2:5])

# 从开始到第4个元素
print(my_list[:-5])

# 第6个元素至结束
print(my_list[5:])

# 元素开始到结束
print(my_list[:])

通过将索引考虑到如下所示的元素之间，切片可以得到最佳的可视化效果。如果我们想要访问一个范围，我们需要两个下标来从列表中分割那部分。(冒号左边闭右边开{ (] }))

如何更改或添加元素到列表？

List是可变的，也就是说，它们的元素可以更改，而不像string或tuple。

我们可以使用赋值运算符（=）更改一个项目或一系列项目。

my_list =['G','0','u','f','3','n']
my_list[1] ='o'
print(my_list)
my_list[2:5]=[6,6,6]#改变3到5
print(my_list)
#['G', 'o', 'u', 'f', '3', 'n']
#['G', 'o', 6, 6, 6, 'n']

我们可以使用append()方法将一个项目添加到列表中，或者使用extend()方法将多个项目添加到列表中。

my_list =['G','0','u','f','3','n']
my_list.append(6)
print(my_list)
my_list.extend([6,6,6,6])
print(my_list)
#['G', '0', 'u', 'f', '3', 'n', 6]
#['G', '0', 'u', 'f', '3', 'n', 6, 6, 6, 6, 6]

此外，我们可以使用insert()方法在需要的位置插入一个项，或者通过将多个项压缩到列表的一个空切片中来插入多个项

odd = [1, 9]
odd.insert(1,3)

# 输出: [1, 3, 9] 
print(odd)

odd[2:2] = [5, 7]

# 输出: [1, 3, 5, 7, 9]
print(odd)

如何从列表中删除或删除元素？

我们可以使用关键字del从列表中删除一个或多个项。它甚至可以完全删除列表。

my_list =['G','0','u','f','3','n']
del my_list[1]
print(my_list)
del my_list[2:5]
print(my_list)
del my_list
print(my_list)
#['G', 'u', 'f', '3', 'n']
#['G', 'u']
#NameError: name 'my_list' is not defined

我们可以使用remove()方法删除给定项目，也可以使用pop()方法删除给定索引处的项目。

如果未提供索引，则pop()方法将删除并返回最后一项。这有助于我们将列表实现为堆栈（先进先出数据结构）。

我们还可以使用该clear()方法清空列表。

my_list =['G','0','u','f','3','n']
my_list.remove('G')#指定将G删除
print(my_list)
print(my_list.pop(1))#将第二位删除并显示出来
print(my_list)#打印出来u
print(my_list.pop())#没有提供索引，默认最后一位删除并显示
print(my_list)#打印出来n
my_list.clear()#清空列表
print(my_list)
#['0', 'u', 'f', '3', 'n']
#u
#['0', 'f', '3', 'n']
#n
#['0', 'f', '3']
#[]

Python列表方法

它们以list.method()方式访问。上面已经使用了某些方法。

Python列表方法
append() -将元素添加到列表的末尾
extend() -将列表的所有元素添加到另一个列表
insert() -在定义的索引处插入一个项目
remove() -从列表中删除一个项目
pop() -删除并返回给定索引处的元素
clear() -从列表中删除所有项目
index() -返回第一个匹配项的索引
count() -返回作为参数传递的项目数
sort() -以升序对列表中的项目进行排序
reverse() -反转列表中项目的顺序
copy() -返回列表的浅表副本

my_list =['G','0','u','f','3','n',6,6]
print(my_list.index('n'))#显示索引
print(my_list.count(6))#计数
second_list =[1,23,3,13,13]
second_list.sort()#升序排列
print(second_list)
second_list.reverse()#逆转
print(second_list)
#5
#2
#[1, 3, 13, 13, 23]
#[23, 13, 13, 3, 1]

列表理解：创建新列表的优雅方式

列表理解是从Python现有列表中创建新列表的一种简洁明了的方法。

列表理解包含一个表达式，后跟方括号内的for语句。

这是一个列出每项增加2的幂的示例。

Python 元组（Tuple）

创建一个元组

通过将所有项目（元素）放在括号内()（以逗号分隔）来创建元组。括号是可选的，但是，使用括号是一个好习惯。

元组可以具有任意数量的项，并且它们可以具有不同的类型（整数，浮点数，列表，字符串等）。

也可以在不使用括号的情况下创建元组。这称为元组包装。

用一个元素创建一个元组有点特殊。

只有一个元素的元组，括号内仅包含一个元素是不够的。我们将需要一个逗号结尾来表明它实际上是一个元组。

my_tuple=("Gu0f3n")#创建一个元组
print(type(my_tuple))#打印元组内容
my_tuple=("Gu0f3n",)#创建只有一个元素的元组
print(type(my_tuple))
my_tuple="Guof3n",#不适用括号进行元组包装（括号可选）
print(type(my_tuple))

#<class 'str'>
#<class 'tuple'>
#<class 'tuple'>

访问元组元素

我们可以通过多种方式访问元组的元素。

1.索引

我们可以使用索引运算符[]访问索引从0开始的元组中的项目。

因此，具有6个元素的元组将具有从0到5的索引。尝试访问元组之外的元素（例如6、7 …）将引发IndexError。

索引必须是整数；因此我们不能使用float或其他类型。如果使用会导致TypeError。

同样，使用嵌套索引访问嵌套元组，如下面的示例所示。

my_tuple =(1,2,2,3,4,5,6)
print(my_tuple[1])
# IndexError:列表索引超出范围
# print(my_tuple[6])

# 索引必须是整数
# TypeError: 列表索引必须是整数，而不是浮点数
# my_tuple[2.0]

#嵌套元组
n_tuple=("Guof3n",[1,1,2],(1,2,3))
print(n_tuple[0][4])
print(n_tuple[2][1])
#2
#3
#2

2.负索引

Python允许对其序列进行负索引。

索引-1表示最后一项，-2表示倒数第二项，依此类推。

my_tuple=("G","u","0","f","3","n")
print(my_tuple[-1])#n
print(my_tuple[-5])#u

3.切片

我们可以使用切片运算符-冒号“：”访问元组中的一系列项目。

和列表差不太多【）

my_tuple=("G","u","o","f","3","n",6,6,6)
print(my_tuple[1:5])#('u', 'o', 'f', '3')
print(my_tuple[:2])#('G', 'u')
print(my_tuple[:-7])#('G', 'u')
print(my_tuple[2:])#('o', 'f', '3', 'n', 6, 6, 6)
print(my_tuple[:])#('G', 'u', 'o', 'f', '3', 'n', 6, 6, 6)

通过考虑索引位于元素之间，可以最好地可视化切片，如下所示。因此，如果要访问范围，则需要将元组中的部分切片的索引。

后面一些类型像字典 元组和列表都大差不差 所以这章先到这里

Python pass 语句

在本文中，您将学习pass语句。 它用作在后面实现函数，循环等的占位符。

什么是Python中的pass语句？

在Python编程中，pass语句为空语句。在Python中，注释和pass语句之间的区别在于，尽管解释器完全忽略注释，而pass不会被忽略。

但是，执行传递时没有任何反应。结果为无操作（NOP）。

pass语法

pass

我们通常将其用作占位符。

假设我们有一个尚未实现的循环或函数，但我们想在将来执行实现它。他们不能有一个空的主体，解释器将给出错误。因此，我们使用该pass语句构造一个不执行任何操作的主体。

'''pass只是一个占位符，
用于以后添加功能。'''

Python 函数

在本文中，您将了解函数、函数是什么、函数的语法、构成和类型。另外，您还将学习如何用Python创建函数。

Python中的函数是什么？

在Python中，函数是一组执行特定任务的相关语句。

函数有助于将我们的程序分解为较小的模块。随着我们的项目越来越大，函数使其变得更加有组织和易于管理。

此外，它避免了重复写相同的代码，函数使代码可重复使用。

函数语法

def function_name(parameters):
	"""docstring"""
	statement(s)

上面显示的是由以下组件组成的函数定义。

1. def标记函数头开始的关键字。
2. 用于唯一标识函数的函数名称。函数命名遵循在Python中编写标识符的相同规则。
3. 通过其将值传递给函数的参数。它们是可选的。
4. 冒号（:)标记函数头的结尾。
5. 可选的文档字符串（docstring），用于描述函数的函数。
6. 组成函数体的一个或多个有效python语句。语句必须具有相同的缩进级别（通常为4个空格）。
7. 可选的return语句，用于从函数返回值。

函数示例

def greet(name):
    """
    这是一个打招呼的函数，
    通过name参数传递，
    要打招呼的人名
    """
    print("Hello, " + name + ". Good morning!")

如何在python中调用函数？

定义函数后，我们可以从另一个函数，程序甚至Python提示符中调用它。要调用函数，我们只需键入带有适当参数的函数名称即可。

return 语句

return语句用于退出函数并返回到调用函数的位置。

回语法

return [expression_list]

该语句可以包含一个表达式，该表达式将被求值并返回值。如果该语句中没有表达式，或者return语句本身不存在于函数中，则该函数将返回None对象。

例如：

>>> print(greet("May"))
Hello, May. Good morning!
None

None是返回值，因为greet()函数直接打印名称，并且没有使用return语句。

def absolute_value(num):
    """这个函数返回输入数字的绝对值"""

    if num >= 0:
        return num
    else:
        return -num


print(absolute_value(2))

print(absolute_value(-4))

2
4

Function如何在Python中工作？

变量的作用域和生命周期

变量的作用域是程序中可以识别该变量的部分。从函数外部看不到在函数内部定义的参数和变量。因此，它们具有本地作用域。

变量的生命周期是变量在内存中退出的时间。函数内部变量的生命周期与函数执行的时间一样长。

一旦我们从函数返回，它们就会被销毁。因此，函数无法记住其先前调用中的变量值。

这是一个示例，用于说明函数内部变量的生命周期。

示例

def my_func():
	x = 10
	print("函数内部值:",x)

x = 20
my_func()
print("函数外部值:",x)

输出结果

函数内部值: 10
函数外部值: 20

在这里，我们可以看到x的初始值为20。即使函数my_func()将x的值更改为10，它也不会影响函数外部的值。

这是因为函数内部的变量x与函数外部的x变量不同。尽管它们具有相同的名称，但是它们是两个具有不同作用域的不同变量。

另一方面，从外部可以看到函数外部的变量。它们具有全局作用域，也就是函数内外部都可以使用该全局变量。

我们可以从函数内部读取这些值，但不能更改（写入）它们。如果要在函数外部修改变量的值，必须使用关键字global，将它们声明为全局变量。

函数类型

基本上，我们可以将函数分为以下两种类型：

1. 内置函数-Python内置的函数。
2. 用户定义的函数 -用户自己定义的函数。