python3基础知识梳理_python3知识点大全-优快云博客

本文链接：https://blog.youkuaiyun.com/a2503099087/article/details/140266418

1.基本数据类型（6种）

不可变数据3个（可以改引用地址）：Number、String、Tuple（元组）
可变数据3个：List（列表）、Dictionary（字典）、Set（集合）

数字Number：

整型int：不限制大小，可以当long用，bool是int的子类型。
浮点型float：可以小数点也可以科学计数法 2.5e2
复数complex： a+bj或者complex（a，b），其中ab都是浮点型
数字运算 + - * /(返回浮点数)  
 **（幂运算）  //  %
 数学函数 ：https://www.runoob.com/python3/python3-number.html

字符串

可以用单引号‘’或者双引号“”创建字符串
val =‘HELLO’
H E L L O
索引：从头开始 0 1 2 3 4
从尾开始 -5 -4 -3 -2 -1
访问变量[头下标:尾下标]
val[:] = ‘HELLO’ val[:3]=‘HEL’
val[0:] = ‘HELLO’

转义字符、字符运算符、字符串格式化、String的函数：https://www.runoob.com/python3/python3-string.html

‘\’(在行尾时)	是续行符	

>>> print("line1 \
... line2 \
... line3")
line1 line2 line3
>>>

r/R所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。
print( r'\n' )
print( R'\n' )

三引号

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)	 
输出结果为
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。

f-string
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

列表

列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
可以用正索引和负索引访问，如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
#!/usr/bin/python3
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])
输出结果为
list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

append 添加元素 list.append（‘Baidu’）
del 删除元素 del list[2] list.remove（‘Baidu’）
len(list) 列表长度
list（seq）将元组转化为列表
其它常用函数https://www.runoob.com/python3/python3-list.html

元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

实例(Python 3.0+)
>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

其它常用方法：
https://www.runoob.com/python3/python3-tuple.html

字典Dictionary

java中的map：字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

字典的特性
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，会报错
创建方式

# 使用大括号 {} 来创建空字典
emptyDict = {}
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))

emptyDict = dict()
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:",len(emptyDict))
 
# 查看类型
print(type(emptyDict))

输出结果
{}
Length: 0
<class 'dict'>
{}
Length: 0
<class 'dict'>

访问字典里的值

如果用字典里没有的键访问数据 会输出错误
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Alice']: ", tinydict['Alice'])

修改与删除字典

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

字典的内置函数&方法：https://www.runoob.com/python3/python3-dictionary.html

集合

集合（set）是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等操作。
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔，或者也可以使用 set() 函数创建集合。
创建格式：

parame = {value01,value02,...}
或者
set(value)

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

1.添加元素 s.add（x）

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

s.update( x )也可以添加元素，且参数可以是列表，元组，字典等，x 可以有多个，用逗号分开。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

2.移除元素s.remove(x)
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

s.discard( x )移除集合中的元素，且如果元素不存在，不会发生错误。
s.pop() 随机删除集合中的一个元素
s.clear()清空集合
len(s) 统计集合个数
集合完整方法：https://www.runoob.com/python3/python3-set.html

2.条件控制

Python 中用 elif 代替了 else if，if语句的关键字为：if – elif – else。
每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

match…case
match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。
case _: 类似于Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

mystatus=400
print(http_error(400))

3.推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 推导式是一种强大且简洁的语法，适用于生成列表、字典、集合和生成器。

列表推导式

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]
或者 
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
out_exp_res：列表生成元素表达式，可以是有返回值的函数。
for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
if condition：条件语句，可以过滤列表中不符合条件的值。

实例
>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

字段推导式

{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }

listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}
>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

集合推导式

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

计算数字 1,2,3 的平方数：

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

判断不是 abc 的字母并输出：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

元组推导式（生成器表达式）

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。
例一个包含数字 1~9 的元组：

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象
>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

4.函数

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

函数内容以冒号 : 起始，并且缩进。

def hello() :
    print("Hello World!")
hello()

传可变参数与不可变参数
https://www.runoob.com/python3/python3-function.html
以下是调用函数时可使用的正式参数类型：

1必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数必须传入一个参数，不然会出现语法错误：

def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
# 调用 printme 函数，不加参数会报错
printme()
Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'

2关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
#调用printinfo函数
printinfo( age=50, name="runoob" )

3默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

名字:  runoob
年龄:  50
------------------------
名字:  runoob
年龄:  35

4不定长参数

一个函数能处理比当初声明时更多的参数，声明时不会命名。

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

实例
#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

输出结果：

输出:
10
输出:
70
60
50

加了两个星号 ** 的参数会以字典的形式导入。

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

实例

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

输出结果
输出: 
1
{'a': 2, 'b': 3}

声明函数时，参数中星号 * 可以单独出现，例如:

def f(a,b,*,c):
    return a+b+c

如果单独出现星号 *，则星号 * 后的参数必须用关键字传入：

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

匿名函数

https://www.runoob.com/python3/python-lambda.html
Python 使用 lambda 来创建匿名函数。
lambda 函数的语法只包含一个语句，如下

lambda [arg1 [,arg2,.....argn]]:expression

设置参数 a 加上 10:

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

15

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。
以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))

22
33

强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
f(10, 20, 30, d=40, e=50, f=60)
#以下为错误调用
f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式