2022年 11月 4日

Python常用基础语法

基本数据类型（字符串、列表、字典）及其内置函数、推导式、循环（for，while）、map函数、lambda函数、递归函数

基础语法

print(r'hello\n') # 加上r，\n不会进行转义

数据类型

Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Number

整型(int) – 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。

浮点型(float) – 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

复数( (complex)) – 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型

type(a)                             # 查询变量类型
isintance(a, int)                   # 判断是否为某类型
1 is True                           # is 判断类型
var1 = 1                            # 创建对象
del var1
del var1, var2                      # 删除对象

+ - * 
a / b                               # 得到一个浮点数
a // b                              # 得到一个整数
a ** b                              # 乘方
a % b                               # 取余

注意：

bool是int的子类，True和False可以和数字相加
在混合计算时，Python会把整型转换成为浮点数。
在交互模式中，最后被输出的表达式结果被赋值给变量下划线”_”

数学函数

abs(x)                              # 绝对值函数
math.ceil(x)                        # 返回数字的上入整数
math.exp(x)                         # e的次幂
math.fabs(x)                        # 数字的绝对值
math.floor(x)                       # 数字的下舍整数
math.log(x, a)                      # log_a(x)，底数为a，如math.log(math.e)返回1.0
math.log10(100)                     # 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)                     # 最大值
min(x1, x2,...)                     # 最小值
modf(x)                             # 返回x的整数部分和小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
pow(x, y)                           # x的y次幂
round(x,n)                          # 四舍五入
sqrt(x)                             # x开二次方

随机数函数

choice(seq)     # 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange(start, stop, step) # 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()        # 随机生成下一个实数，它在[0,1)范围内。
seed(x)         # 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(list)   # 将序列的所有元素随机排序
uniform(x, y)   # 随机生成下一个实数，它在[x,y]范围内。

三角函数

acos(x)         # arccosx
asin(x)         # arcsinx
atan(x)         # arctanx
atan2(y, x)     # 返回给定的 X 及 Y 坐标值的反正切值。
cos(x)
hypot(x, y)     # 返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)
tan(x)
degrees(x)      # 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)      # 将角度转换为弧度

字符串, 左闭右开

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到[倒数第二个]的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str) 
print (str + "TEST") # 连接字符串

格式化字符串

%c  # char字符
%s  # string字符串
%d  # digit整数
%u  # unsigned无符号整型
%o  # 无符号八进制数
%x  # 无符号十六进制数
%X  # 无符号十六进制数-大写
%f  # float 浮点数，可指定精度
%e 或 %E  # 科学计数法格式化浮点数
%g  # %f加上%e 科学技术法格式化浮点数
%G  # %f加上%E
%p  # 用十六进制数格式化变量地址

*   # 定义宽度或小数点精度
-   # 左对齐
+   # 在正数前面显示加号
<sp># 在正数前面显示空格
#   # 在八进制数前面显示零，在十六进制前面显示0x或0X
0   # 显示的数字前面填充0，而不是默认的空格
%   # ’%%‘输出一个单一的’%‘
(var)# 映射变量（字典参数）
m.n.# m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

格式化函数:

基本语法是通过 {} 和 : 来代替以前的 % 。
括号里可以直接写进，也可以用**字典、列表索引、对象

str.format()    #格式化函数

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 网站名：菜鸟教程, 地址 www.runoob.com

# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
# 网站名：菜鸟教程, 地址 www.runoob.com

# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
# 网站名：菜鸟教程, 地址 www.runoob.com

# 向 str.format() 传入对象：
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

数字格式化：
https://www.runoob.com/python/att-string-format.html

{:.2f}
{:+.2f}
{:-.2f}
{:.0f}
{:0>2d}
{:x<4d}
{:,}
{:.2%}
{:.2e}
{:>10d}
{:<10d}
{:^10d}
{:b}
{:d}
{:o}
{:x}
{:#x}
{:#X}

字符串内建函数

string.capitalize()     # 第一个字符大写
string.swapcase()       # 反转大小写
string.title()          # 所有单词以大写开始，其余字母均为小写
string.translate(str, del="") # 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

string.center(width)    # 返回原字符串居中，其他位置用空格填充
string.ljust(width)     # 返回一个原字符串左对齐，并使用空格填充至字符串width的新字符串
string.rjust(width) # 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.strip()          # 截掉前后的空格
string.lstrip()         # 截掉 string 左边的空格
string.rstrip()         # 截掉 string 右边的空格

string.count(str, beg=0, end=len(string)) # 返回str在string的[begin, end)出现的次数
string.decode(encoding='UTF-8', errors='strict) # 以对应编码格式解码string
string.encode(encoding='UTF-8', errors='strict') # 以对应编码格式编码string

string.startswith(obj,beg=0,end=len(string)) # 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查
string.endswith(obj, beg=0, end=len(string))    # 检查字符串是否以obj结束
string.find(str, beg=0, end=len(string))    # 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.index(str, beg=0, end=len(string))   # 跟find()方法一样，只不过如果str不在 string中会报一个异常.

string.format()     # 格式化字符串
string.lower()      # 全部小写
string.expandtabs(tabsize=8)    # 把字符串string中的tab符号转为空格，默认空格数为8个


string.isalnum()    # is alphabet or num -> 如果 string 至少有一个字符 并且 所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha()    # 如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()  # 如果 string 只包含十进制数字则返回 True 否则返回 False.
string.islower()    # 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()  # 如果string中只包含数字字符串，则返回True，否则返回false
string.isspace()    # 如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()    # 如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()    # 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

string.join(seq)    # 以string作为分隔符，将seq中所有的元素合并成为一个新的字符串
string.maketrans(intab, outtab) # maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 https://www.runoob.com/python/att-string-maketrans.html

max(str)            # str中最大的字母
min(str)            # str中最小的字母

string.partition(str) # 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.rpartition(str) # 类似于 partition()函数,不过是从右边开始查找
string.split(str, num=string.count(str))    # 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string.splitlines(keepends)   # 按照行('\r', '\r\n', '\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

string.replace(str1, str2, num=string.count(str1)) # 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0, end=len(string)) # 类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
string.rindex(str, beg=0, end=len(string)) # 类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。

列表List

    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ") 
    
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) 
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1] 
    
    # 重新组合字符串
    output = ' '.join(inputWords)

列表增删改查

list = ['abc', 123, 1.23]
list1 = ['abc', 123, 1.23]
list2 = ['abc', 123, 1.23]

list                # 获得完整列表
list[0]             # 第一个元素
list[1:3]           # 2-3个元素（左闭右开）
list[2:]            # 从第三个元素开始的所有元素

list = []
list.append()       # 添加元素
del list[n]         # 删除元素
len(list)           # 长度
list1+list2         # 组合
list * 4            # 重复
'abc' in list       # 元素是否在列表中
for x in list: ...  # 迭代

Python列表函数和方法

cmp(list1, list2)       # 比较两个列表的元素
max(list) min(list)     # 最大最小值 字符串按字典排序
list(seq)               # 将元组转换为列表

lst.append(x)           # 添加对象
lst.count(x)            # 统计出现次数
lst.extend(seq)         # 在列表末尾一次性追加另一个序列中的多个值
lst.index(obj)          # 从列表中找出某个值第一个匹配项的索引位置
lst.insert(index, obj)  # 将对象插入列表
lst.pop(index=-1)       # 移除列表中的（默认最后一个）一个元素，并返回该元素的值
lst.remove(obj)         # 移除列表中某个值的第一个匹配项
lst.reverse()           # 反向列表中的元素
lst.sort(cmp=None, key=None, reverse=False) # 对列表进行排序

数据类型转换

int(x [,base]) #将x转换为一个整数
long(x [,base] ) #将x转换为一个长整数
float(x) #将x转换到一个浮点数
complex(real [,imag]) #创建一个复数
str(x) #将对象 x 转换为字符串
repr(x) #将对象 x 转换为表达式字符串
eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) #将序列 s 转换为一个元组
list(s) #将序列 s 转换为一个列表
set(s) #转换为可变集合
dict(d) #创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) #转换为不可变集合
chr(x) #将一个整数转换为一个字符
unichr(x) #将一个整数转换为Unicode字符
ord(x) #将一个字符转换为它的整数值
hex(x) #将一个整数转换为一个十六进制字符串
oct(x) #将一个整数转换为一个八进制字符串

推导式

列表推导式

names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper() for name in names if len(name)>3]

multiples = [i for i in range(30) if i % 3 == 0]

字典推导式

listdemo = ['Google','Runoob', 'Taobao']
newdict = {key : len(key) for key in listdemo}
# {'Google': 6, 'Runoob': 6, 'Taobao': 6}

dic = {x : x**2 for x in (2,4,6)}
# {2: 4, 4: 16, 6: 36}

集合推导式

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

str = 'abracadabra'
a = {x for x in str if x not in 'abc'}
# {'d', 'r'}

元组推导式

a = (x for x in range(1, 10)) 
# <generator object <genexpr> at 0x7faf6ee20a50>  
# 返回的是生成器对象

tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组

运算符

位运算符

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
# 按位与运算，两者都为1才是1 
c = a & b        # 12 = 0000 1100 
print ("1 - c 的值为：", c)

# 按位或运算，其中一个是1就是1
c = a | b        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
 
# 异或运算，两者相同则为1
c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值为：", c)
 
# 按位取反
c = ~a           # -61 = 1100 0011
print ("4 - c 的值为：", c)

# 左移动n位，右边补0
c = a << 2       # 240 = 1111 0000
print ("5 - c 的值为：", c)
 
# 右移动n位，左边补0
c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值为：", c)

元组 Tuple

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组增删改查

创建元组
tup1 = ()           # 空元组
tup1 = (50, )       # 元组中只包含一个元素时，需要在元素后面添加逗号


访问元组
tup1[0]
tup1[1:5]

修改元组
tup[0] = 100 # 这样直接赋值修改元组元素操作是非法的！！！
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup3 = tup2 + tup1 # 创建一个新的元组

删除元组
del tup

元组运算符

len(tup1)       # 长度
tup1+tup2       # 连接
tup1 * 4        # 复制
3 in (1,2,3)    # 元素是否存在
for x in (1,2,3):...    # 迭代

元组索引，截取

tup = ('spam', 'Spam', 'SPAM!')

tup[2]      # 读取第三个元素
tup[-2]     # 倒数第二个
tup[1:]     # 截取元素

任意无符号的对象，以逗号隔开，默认为元组

x, y = 1, 2
print("Value of x , y : ", x,y)
# Value of x , y : 1 2

元组内置函数

cmp(tp1, tp2)       # 比较
len(tp1)            # 长度
max(tp1) min(tp1)   # 返回元组中元素的最大值/最小值
tuple(seq)          # 将列表转换为元组

字典Dictionary

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中

d = {key1 : value1, key2 : value2 }

注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

创建字典
tinydict = {'a' : 1, 'b': 2}
tinydict2 = { 'abc': 123, 98.6: 37 }

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

字典增删改查

dic[key]            # 查
dic[key] = value    # 改/增

del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典

内置函数

cmp(dic1, dic2)         # 比较两个字典元素
len(dic)                # 长度
str(dic)                # 输出字典可打印的字符串表示
type(variable)          # 返回输入的变量类型，如果变量是字典就返回字典类型。

dt.clear()              # 删除字典内所有元素
dt.copy()               # 返回一个字典的浅复制
dt.fromkeys(seq)        # 创建一个新字典，以序列seq中元素做字典的键
dt.get(key, default=None)# 返回指定键的值，如果值不在字典中则返回default值
dt.has_key(key)         # 如果键在字典dict里，返回true，否则返回false
dt.items()              # 以列表返回可遍历的（键、值）元组数组
dt.keys()               # 返回字典所有的键（列表形式）
dt.setdefault(key, default=None) # 和get()相似，但如果键不存在于字典中，将会添加键并将值设置为 default
dt.update(dict2)        # 把字典dict2的键值对更新到dt里
dt.values()             # 以列表返回字典中所有值
pop(key)                # 删除字典给定键key所对应的值，返回值为被删除的值，key必须给出，
popitem()               # 返回并删除字典中的最后一对键和值

lambda函数

在Python中，我们使用lambda关键字来声明一个匿名函数，这就是为什么我们将它们称为“lambda函数”。匿名函数是指没有声明函数名称的函数。尽管它们在语法上看起来不同，lambda函数的行为方式与使用def关键字声明的一般函数相同。以下是Python中 lambda函数的特点:

lambda函数可以接受任意数量的参数，但函数只能包含一个表达式。表达式是lambda函数执行的一段代码，它可以返回任何值，也可以不返回任何值。

product = lambda x, y: x * y 
print(product(2.3))

原文链接：https://blog.csdn.net/sinat_38682860/article/details/88917715

Python内置函数

map函数

>>> def square(x) :         # 计算平方数
...     return x ** 2
... 

>>> map(square, [1,2,3,4,5])    # 计算列表各个元素的平方
<map object at 0x100d3d550>     # 返回迭代器

>>> list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表
[1, 4, 9, 16, 25]

>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

filter函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

过滤出1~100中平方根是整数的数

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101))
print(newlist)

>>> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

reduce()

reduce() 函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：

用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，
得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

from functools import reduce

def add(x, y) :            # 两数相加
    return x + y
    
sum1 = reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5

sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数

print(sum1) # 15
print(sum2) # 15

zip()
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
打包变成tuple->list

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]

其他函数

divmod(a, b)        # 返回a//b和a%b 商和余数

ord(c)              
# ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。 a->'97'

any(iterable)
# any() 函数用于判断给定的可迭代参数 iterable(元组或列表) 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

eval()
# eval() 函数用来执行一个字符串表达式，并返回表达式的值。
>>> x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

str()
# str() 函数将对象转化为适于人阅读的形式。
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"


file()
# 创建file对象
>>>f = file('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'

execfile()
# 执行文件

issubclass(A, B)
# A 是不是 B的subclass

frozenset() 
# 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

list.reverse()
# reverse() 函数用于反向列表中元素。

set()
# set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

dict()
>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>>