python知识点

这里记录了一些初学Python代码时遇见的知识点。

string函数

string模块中记录了一些常用的属性

数字，字母等

ascii

import string

print(string.ascii_letters) //'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
print(stirng.ascii_lowercase) //'abcdefghijklmnopqrstuvwxyz'
print(string.ascii_uppercase) //'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
print(string.digits) //'0123456789'

大小写转化

**upper()**可以将字符串变为大写，可单独使用，可也以放进print
**lower()**可以将字符串变为小写，可单独使用，可也以放进print

print(s.upper()) //注意只是生成新的字符串，并没有更改

大小写反转

swapcase()

print(s.swapcase())

首字母大写

**title()**所有给的单词首字母大写，其余小写
**capitalize()**只大写整个字符串的第一个字母,其余小写

import string
s = "abcd,qwerTYU"
t = "abcd qwerTYU"
print(s.title())    //Abcd,Qwertyu
print(s.capitalize())   //Abcd,qwertyu
print(t.title())    //Abcd Qwertyu
print(t.capitalize())   //Abcd qwertyu

is判断函数

**isdecimal()**判断字符串是否全部为数字
**isalpha()**判断字符串是否全部为字母
**isalnum()**判断给定的字符串是否只含有数字与字母
**isupper()**判断给定的字符串是否全为大写
**islower()**判断给定的字符串是否全为小写
**istitle()**判断给定的字符串是否符合title()
isspace():判断给定的字符串是否为空白符（空格、换行、制表符）

// \n为换行 是空白符 为True
print("\n".isspace())

isprintable():判断给定的字符串是否为可打印字符（只有空格可以，换行、制表符都不可以）

// \t为制表符 不可打印 为False
print("\t".isprintable())

isidentifier():判断给定的字符串是否符合命名规则（只能是字母或下划线开头,且不能包含除数字、字母和下划线以外的任意字符

// qe123 符合命名规则 为True
print("qe125".isidentifier())

字符串填充

居中：center(,)//原内容会出现在中间，填充物在两边
居左：ljust(,)//原内容会出现在左边，填充物在右边
居右：rjust(,)//原内容会出现在右间，填充物在左边
zfill()//居右填充，但会识别数字的正负

import string
print("qwer".ljust(10,"+")) //qwer++++++
//这里的“10”指字符串总长度
# 不加"+""-"纯数字，用填充物"0"将字符串前填充满
print("12345".zfill(10))  # 0000012345
# 加"-"纯数字，越过"-"用填充物"0"将字符串前填充满
print("-125".zfill(10))  # -0000012345
# 加"+"数字字母组合，越过"+"用填充物"0"将字符串前填充满
print("+qwe125".zfill(10))  # +000qwe125
# 加其他符号，用填充物"0"将字符串前填充满
print("#qwe12".zfill(10))  # 0000#qwe12

字符串搜索

**count(string,strat,end)*，搜索是否含有string，返回出现的次数*

import string
# 全部字符串内 搜索qwe 出现的次数
print("qwertasdqwezxcqwe".count("qwe"))     //结果为3
# 由于字符串从0开始计数，1为字符串第二个，相当于从w开始
print("qwertasdqwezxcqwe".count("qwe",1))     //结果为2
# 从字符串第 2个开始到第15个截止，共出现qwe的次数     //结果为1
print("qwertasdqwezxcqwe".count("qwe",1,14))

startswith(string,start,end),endswith(string,start,end),判断函数的开始或末尾是否为制定字符串。同样，可以加边界

强调：这里的不仅可以输入子字符串，还可以输入元组，若为元组时候只要有一个成真即为True

import string
print("qwertasdqwezxcqwe".startswith("qwe"))    //结果为True
print("qwertasdqwezxcqwe".startswith("qwe",1))    //从1开始搜索，为"wer"，故为False
print("qwertasdqwezxcqwe".endswith("qwe","asd"))    //元组，其中有一个符合，为True

find(sub[, start[, end]]) 返回第一个子字符串的位置信息，若无则为-1
**rfind(sub[, start[, end]])**返回最右边的第一个子字符串的位置信息，若无则为-1
index(sub[, start[, end]]) 返回第一个子字符串的位置信息，若无则为报错
**rindex(sub[, start[, end]])**返回最右边的第一个子字符串的位置信息，若无则报错

import string 
s="qweraqwesfgzqweop"
print(s.find("qwe"))    //0
print(s.rfind("qwe"))   //12
print(s.index("qwe"))   //0
print(s.rindex("qwe"))  //12

字符串替换

**replace(old,new,number)**将就字符串修改为新字符串，后可设置修改个数

import string 
s="qweraqwesfgzqweop"
# 将字符串全部的qwe  换为asd
print(s.replace("qwe","asd"))
# 将字符串前两个qwe  换为asd
print(s.replace("qwe","asd",2))
# 将字符串全部的qew  换为asd 没有则输出原字符串
print(s.replace("qew","asd"))

**expandtabs(N)**将\t 改为一定数量的空格
空格计算方式：
N-（之前字符串长度）= 空格数
若N-（之前字符串长度）=0 则空格数为N
若N-（之前字符串长度）<0 则空格数为1

import string 
t="qwe\tqwer\tqasdsdf\tas"
print(t.expandtabs(4))

//第一个\t ：设定长度为4，之前字符串qwe长度为3，4-3=1 替换1个空格
//第二个\t ：设定长度为4，之前字符串qwer长度为4，4-4=0 替换4个空格
//第三个\t ：设定长度为4，之前字符串qsdfsdf长度为7，4-7=-3<0 替换1个空格

字符串分割

partition(string),rpartition(string),可以将字符串分割为三部分。首先找string，若找到了，正常分割；若没找到用空格补充

import string 
t="qwertyuasdfghjkl"
print(t.partition("yua"))   //('qwert', 'yua', 'sdfghjkl')
print(t.partition("asqw"))  //('qwertyuasdfghjkl', '', '')
print(t.rpartition("asqw")) //('', '', 'qwertyuasdfghjkl')

split(),常与input共用

import string 
t=input().split()
print(t)

字符串添加

join()将可迭代数据（字符串string、列表list、元组tuple、字典dict、集合set）连接起来.
参与迭代的每个元素必须是字符串类型，不能包含数字或其他类型。

import string 
a="qwer"
print("_".join(a))  //q_w_e_r

b=("a","b","c","d") //a=b=c=d
print("=".join(b))

c={"qwe","asd","zxc"}
print(" ".join(c))  //asd qwe zxc
//集合也是这样，但是需要注意，集合的无需性，所以顺序可能颠倒

字符串修剪

**strip(char)**移除字符串内char。若不填，则移除空格、制表符、换行符。注意移除到非char停止。
**lstrip()**中 l为left缩写，函数表示从左到右遍历
**rstrip()**中 r为right缩写，函数表示从右边开始遍历

import string 
a="    qweasdzxcrtqwe    "
print(a.strip())    //qweasdzxcrtqwe

b="qweasdzxcrtqwe    "
print(b.lstrip('q'))    //weasdzxcrtqwe    
//字符串从左开始第一个为q，是传入参数移除，第二个w不是传入参数，修剪停止，将剩下所有输出

c="   qweasdzxcrtqwe"
print(c.rstrip('qew'))  //   qweasdzxcrt
//字符串从右开始，第一个为q在传入参数中，同理第二个、第三个也在，所以移除，第四为t不在传入参数中，将剩下所有输出

进制转换

一、任意进制转换十进制

print( int( string , ? ))

s = '1001'
print(int(s,2)) //二进制
print(int(s,8)) //八进制

二、十转其他任意进制

print( ? ())

print(bin(10))      //二进制
print(oct(100))     //八进制
print(hex(1033))    //十六进制

三、format()转换

format(x,’b’) #将x转换为二进制
format(x,’o’) #将x转换为八进制
format(x,’d’) #将x转换为十进制
format(x,’x’) #将x转换为十六进制

list的常见用法

list内部函数

len() ：求列表元素个数
max() ：求列表最大值
min() ：求列表最小值
sum() ：求列表的和
sorted():求排序后的列表序列
**list()**：将其他数据结构转换为列表
any() :只要列表里有一个True就会返回True
**all()**：表里的所有元素都是True才会返回True

list函数

**list.append(元素)**：在末尾添加一个元素
**list.insert(n,元素)**：可以看作是更强大的append，在特定的位置插入数据
**list.pop(n)**：返回删除特定位置的元素(删了谁，返回的结果就是谁)
**list.remove()**：删除指定元素
**list1.extend(list2)**：合并list2到list1后面
**list.clear()**：清空列表
**list.copy()**：因为列表容易被改变，操作的时候使用copy复制一个列表，就不会改变原列表的数据啦~
**list.index(元素)**：搜索元素在序列的第几个位置，返回一个数字位置
**list.count()**：计算某个元素在列表中出现的次数
list.reverse():调转排序

ls1.reverse()
print(ls1)

**list.sort()**：从小到大
**list.sort(reverse=True)**：从大到小

list.sort() 与 sorted(list)函数的主要 区别：

1. sort 是应用在 list 上的方法，属于列表的成员方法，sorted 可以对所有可迭代的对象进行排序操作。
2. list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
3. sort使用方法为ls.sort()，而sorted使用方法为sorted(ls)

快速生成表格

[expression for i in iterable]
其中，expression 是用来计算新列表中每个元素的表达式，i 是原列表中的每个元素，iterable 是原列表。

作用

列表推导式的作用是将一个列表中的元素通过一定的方式映射为另一个列表中的元素。例如，下面的代码可以将一个列表中的所有元素平方，并生成一个新的列表

a = [1, 2, 3, 4, 5]
b = [x**2 for x in a]
print(b)   # 输出 [1, 4, 9, 16, 25]

try

在Python中，try语句用于处理可能引发异常的代码块。try语句的基本语法如下：

try:
    # 可能会引发异常的代码块
except ExceptionType1:
    # 处理 ExceptionType1 类型异常的代码块
except ExceptionType2:
    # 处理 ExceptionType2 类型异常的代码块
else:
    # 如果没有引发任何异常，执行的代码块
finally:
    # 无论是否引发异常，都会执行的代码块

在这个语法中，try语句块中包含了可能会引发异常的代码。当代码块中的代码引发异常时，Python会跳转到与异常类型匹配的except语句块，并执行其中的代码。如果多个except块都匹配，Python将执行第一个匹配的except块。如果没有匹配的except块，异常将继续向上层调用栈传播。

如果没有引发任何异常，Python将执行else语句块中的代码。else语句块是可选的，它包含的代码将在try代码块中没有引发任何异常时执行。

无论是否引发异常，finally语句块中的代码都会执行。finally语句块也是可选的，它包含的代码将在try代码块中引发异常或者没有引发异常时都执行。

例：

try:
    num1 = int(input("请输入一个整数："))
    num2 = int(input("请输入另一个整数："))
    result = num1 / num2
    print("结果是：", result)
except ValueError:
    print("输入的不是整数，请重新输入。")
except ZeroDivisionError:
    print("除数不能为零，请重新输入。")
except:
    print("发生了一个未知异常。")
else:
    print("没有发生异常。")
finally:
    print("程序结束。")

字典嵌套

例如，如果我们有一个包含三个城市信息的字典，可以这样使用该代码：

cities_dict = {
    'Beijing': {"Capital": 'China'},
    'Moscow': {"Capital": 'Russia'},
    'Paris': {"Capital": 'France'}
}

for i in sorted(cities_dict.keys()):
    print(f"{i} is the capital of {cities_dict[i]['Capital']}!")

输出：

Beijing is the capital of China!
Moscow is the capital of Russia!
Paris is the capital of France!

建立字典

keys = input().split()
values = input().split()
print(dict(zip(keys,values)))

lambda函数

在Python中，lambda函数是一种匿名函数，也称为“一次性函数”或“内联函数”。与常规函数不同的是，lambda函数没有名称，可以作为表达式在代码中使用，并且只能包含一个表达式。

lambda函数的一般语法如下：

lambda arguments: expression
其中，arguments是函数的参数，可以是多个参数，用逗号分隔。expression是一个表达式，可以是任意复杂度的表达式，但不能包含语句或控制流语句（如if、for、while等）。

例如，以下是一个简单的lambda函数，用于计算两个数的和：

sum = lambda x, y: x + y

这个函数可以像常规函数一样调用，例如：

result = sum(3, 5)
print(result)  # 输出 8

lambda函数通常用于在代码中定义简单的函数，或作为其他函数的参数。例如，可以在sorted()函数中使用lambda函数，指定排序的关键字。下面的示例对一个列表中的元素按照长度进行排序：

words = ["apple", "banana", "orange", "pear", "grape"]
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)  # 输出 ["pear", "apple", "grape", "banana", "orange"]

这里的lambda函数指定了key参数，用于指定排序的关键字。该函数返回字符串的长度，作为排序的依据。通过这种方法，可以方便地对列表中的元素按照不同的属性进行排序。