python记录

0. 零零碎碎

0.0 推荐个网站

有啥不会的搜着比较方便
RUNOOB
鱼C课后题
谷歌翻译

0.1 条件表达式（三元操作符）

举个栗子：

x,y = 4,5
if x<y:
    small = x
else:
    small = y
#改进 
small = x if x<y else y

0.2 断言（assert）

assert

后面程序为假时，程序自动AssertionError

确保程序中的某个条件一定为真才能正常工作

1.列表

1.1 增删改查：

增：

函数	用法	备注
append	最后加	只加一个元素
insert	位置＋元素	只加一个元素
extend	列表

删：

函数	用法
remove	only元素名字
del	del 列表名字 [ 索引值 ]
pop	pop（索引值）

切片：list [ a:b ]

1.2 操作符（dir(list)）

1. list可直接数学运算
   eg：list*3
2. 元素 in/not in 列表名
3. 嵌套列表用法很像二维数组
4. index 索引
5. reverse 反转
6. sort 快排 （小 — 大）
   list.sort(reverse =True)（大 — 小）
7. list1 = list2：指向同一个数组
   list1 = list2[:]：拷贝得到新数组

1.3 列表小帮手range

for i in range(1,5):
    print(i)
#1 2 3 4

for i in range(1,5,2):
    print(i)
#1 3

2. 元组（）

元组：被 ( ) 包围，用“，”隔开的一组数据

temp = （1,2,3,4,5）

增：temp = temp[:2] + (6,) + temp[2:]
删：del temp

PS：增就相当于切片，注意括号以及逗号

3. 字符串

查：str( 索引值 )
增：str[:6] + ‘待添加字符串’ + str[6:] ：其实就是个拼接

3.1 常用函数 dir(str)

函数	用法
capitalize()	首字母大写
casefold()	全部字母小写
center(width)	字符串居中，用空格填充至长度为width
count(sub[,start[,end]])	返回sub在字符中种出现次数，start、end表示参数范围，可选
encode(encoding = ‘utf-8’,errors = ‘strict’)	以encoding指定的编码格式对字符串进行编码
endswith(sub[,start[,end]])	检查字符串是否以sub子字符串结束，是：True；否：False，start、end表示参数范围，可选
expandtabs([tabsize = 8])	把字符串中的tab(\t)转换为空格，如不指定，默认为8
find(sub[,start[,end]])	检测sub是否包含在字符串中，是：return 索引值；否：return -1，start、end表示参数范围，可选
index(sub[,strat[,end]])	跟find一样，但是如果sub不在str里会异常
isalnum()	字符串至少有一个字符且所有字符都是数字或字母
isalpha()	字符串至少有一个字符且所有字符都是字母
isdecimal()	字符串只包含十进制数字
isdigit()	字符串只包含数字
islower()	字符都是小写
isnumeric()	只包含数字
isspace()	字符串只包含空格
istitle()	字符串标题化（首字母大写）
isupper()	全部为大写字符
join(sub)	以字符串为分隔符，插入到sub中所有字符之间
ljust(width)	返回一个左对齐的字符串，空格填充
lower()	大写转为小写
lstrip()	去掉左边所有空格
partition(sub)	找到sub，把字符串分为三元组（pre_sub, sub, fol_sub），若字符串不包含sub，则返回（‘原字符串’,’ ‘,’ '）
replace(old,new[,count])	把字符串中old子串替换为new子串，若count指定，则替换不超过count次
rfind(sub([,start[,end]])	类似find，从右边开始查找
rindex(sub[,start[,end]])	类似index，右边开始
rjust(width)	右对齐，空格补位
rpartition(sub)	类似partition，右边开始查找
rstrip()	删除字符串末尾空格
split(sep = None, maxsplit = -1)	默认以空格为分隔符切片字符串，maxsplit值表示分割次数
splitlines([keepends])	按照\n分离，返回一个包含各行作为元素的列表，返回前keepends行
startswith(prefix[,start[,end]])	检查字符串是否以prefix开头
strip([chars])	删除字符串前后空格，chars可指定删除的字符
swapcase()	大小写反转
title()	开头大写，其他小写
translate(table)	根据table的规则（由str.maketrans(‘a’,‘b’)定义）进行字符转换
upper()	小写全部转为大写
zfill(width)	字符串右对齐，前面补0

以上函数不用特意记，用的时候查即可，只需要知道有这些个功能

PS：几个栗子

• split：

str2='zx#cvbn#fbn#dfbnm'
print(str2.split('#',2))
#['zx', 'cvbn', 'fbn#dfbnm']

• splitlines:

'ab c\n\nde fg\rkl\r\n'.splitlines()
#['ab c', '', 'de fg', 'kl']
'ab c\n\nde fg\rkl\r\n'.splitlines(True)
#['ab c\n', '\n', 'de fg\r', 'kl\r\n']`

• translate：

intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)   # 制作翻译表
str = "this is string example....wow!!!"
print (str.translate(trantab))
#th3s 3s str3ng 2x1mpl2....w4w!!!

3.2 字符串格式化符号含义

符号	说明
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化定点数，可指定小数点后精度
%e	科学记数法格式化定点数
%E	同 %e
%g	根据值的大小决定用 %f / %e
%G	同 %g

补一个强大的 format

3.3 格式化操作符辅助指令

符号	说明
m.n	m：最小总宽度；n：小数点后的位数
-	左对齐
+	正数前面显示加号
#	八进制数前：’ o‘；十六进制数前：’ 0x‘，’ 0X‘
0	显示的数字前补0取代空格

3.4 转义字符

符号	说明
\’	单引号
\"	双引号
\a	alarm
\b	退格
\n	换行
\t	Tab 横向制表符
\v	纵向制表符
\r	回车
\f	换页
\o	八进制数
\x	十六进制数
\0	一个空字符
\\	反斜杠

4. 序列

list()：转为列表
tuple([iterable])：转为元组，iterable ：要转换为元组的可迭代序列。
str()：转为字符串
len()：长度
min()：最小
max()：最大（杂串列表报错）
sum(iterable[,start = 0])：求和，start为求和后额外加的数
sorted()：小 – 大
reversed() : 反转，返回迭代器对象
enumerate()：添加索引
zip()：压缩

栗子：

list1 = (1,6,2,3,9,4,5,6)
list2 = (5,5,3,8,4)

print(tuple(list1))
# (1, 6, 2, 3, 9, 4, 5, 6)
print(len(list1))
# 8
print(max(list1))
# 9
print(min(list1))
# 1
print(sum(list1))
# 36
print(sum(list1,2))
# 38
print(sorted(list1))
# [1, 2, 3, 4, 5, 6, 6, 9]
print(list(enumerate(list1)))
# [(0, 1), (1, 6), (2, 2), (3, 3), (4, 9), (5, 4), (6, 5), (7, 6)]
print(list(reversed(list1)))
# [6, 5, 4, 9, 3, 2, 6, 1]
print(list(zip(list1,list2)))
# [(1, 5), (6, 5), (2, 3), (3, 8), (9, 4)]

5. 函数

5.1 形参 & 实参

def explanation(name):
    # 定义过程中 name 叫形参
    print('传来的' + name + '叫实参，为具体数值')

explanation('11')
# 传来的11叫实参，为具体数值

5.2 可变参数

printf定义中的*arg就是可变参数，它的类型为tuple，代表了除fmt参数之外的所有传入参数
但如果我们传入的可变参数是字典，那么*arg的定义就不够用了，这时我们应该使用**arg来定义函数

def testFun1(**arg):
    for k in arg.keys():
        print("arg[%s] = %s.", k, arg[k])

def testFun2(*arg1, **arg2):
    print(arg1)
    print(arg2)
    
if __name__ == '__main__':
    print("How do you do? %d, %d", 2, 3)
    testFun1(One=1, Two=2)
    testFun2(1, 2, 3, One=1, Two=2, Three=3)

'''
How do you do? %d, %d 2 3
arg[%s] = %s. One 1
arg[%s] = %s. Two 2
(1, 2, 3)
{'One': 1, 'Two': 2, 'Three': 3}
'''

此处借鉴了一下别人代码：链接奉上

5.3 常用函数

1. global：在函数中定义全局变量
2. nonlocal：声明不是局部变量
3. lambda：匿名函数，格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式，其实lambda返回值是一个函数的地址，也就是函数对象
   优点：
   脚本时省略函数定义过程；
   不需要起函数名；
   提高可读性，省去回看函数过程
4. filter：过滤器
5. map：映射返回一个新列表

举个栗子：
lambda：

g = lambda x,y: x*5+y*y
print(g)
print(g(6,7))

#  at 0x000001FD218C4378>
# 79

filter：

def odd(n):
    return n % 2 == 1

newlist = filter(odd, range(10))
print(newlist)
print(list(newlist))
# 
# [1, 3, 5, 7, 9]

map:

list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
# [3, 7, 11, 15, 19]

6. 递归

老栗子了，汉诺塔：
一搜一堆，我就不写过程了

def move(n,x,y,z):
    if n == 1:
        print(x,'->',z)
    else:
        move(n-1,x,z,y)
        # 前 n-1个从 A挪到 B
        print(x,'->',z)
        # A 最下面的挪到 C
        move(n-1,y,x,z)
        # 前 n-1个从 B 挪到 C

n = int(input('num:'))
move(n,'A','B','C')



# 验证过程代码，纯属为了看明白代码咋跑的
#看不明白也没关系，思路对了就行，我就在代码运行这儿浪费了很多时间。。
def move(n,x,y,z):
    if n == 1:
        print(x,y,z,'|',x,'->',z)
    else:
        print('00',x,y,z,n)
        move(n-1,x,z,y)
        # 前 n-1个从 A 挪到 B
        print(n,x,y,z,'|',x,'->',z)
        # A 最下面的挪到 C
        move(n-1,y,x,z)
        # 前 n-1个从 B 挪到 C
        print(n,x,y,z)

n = int(input('num:'))
move(n,'A','B','C')

7. 字典

详细参考我之前写的吧，搬不过来，一复制就乱码： 鲸骨 开！

8. 集合（set）

集合中不会有重复元素

num1 = list(set(num1))
# 会改变元素顺序
num1 = num1.add()
num1 = num1.remove()

不可变集合

num1.frozen([1,2,3,6,5])

9. 文件

9.1 函数

函数

9.2 例子

import pickle

f = open('test.txt')

L = []
J = []
count = 1

for eachline in f:
    if eachline[:8]!='========':
        (name,line_spoken) = eachline.split(':',1)
        if name == '吕':
            L.append(line_spoken)
        if name == '姬':
            J.append(line_spoken)
    else:
        L_name = 'L_' + str(count) + '.txt'
        J_name = 'J_' + str(count) + '.txt'

        L_file = open(L_name,'wb')
        J_file = open(J_name,'wb')

        pickle.dump(L,L_file)
        pickle.dump(J,J_file)

        L_file.close()
        J_file.close()

        count += 1
        L = []
        J = []

    L_name = 'L_' + str(count) + '.txt'
    J_name = 'J_' + str(count) + '.txt'

    L_file = open(L_name, 'wb')
    J_file = open(J_name, 'wb')

    pickle.dump(L, L_file)
    pickle.dump(J, J_file)

    L_file.close()
    J_file.close()

    count += 1
    L = []
    J = []

f.close()

9.3 os模块

os模块

9.4 os.path模块

os.path模块

9.5 举个栗子

import os

def print_pos(key_dict):
    keys = key_dict.keys()
    keys = sorted(keys)
    # 因为字典无序
    for each_key in keys:
        print('关键字出现在第 %s 行，第 %s 个位置' % (each_key,str(key_dict[each_key])))


def pos_in_line(line,key):
    pos = []
    begin = line.find(key)
    while begin != -1:
        pos.append(begin + 1)
        begin = line.find(key,begin + 1)

    return pos

def search_in_file(file_name,key):
    f = open(file_name)
    count = 0
    #记录行数
    key_dict = dict()
    #字典，key所在行对应位置

    for each_line in f:
        count += 1
        if key in each_line:
            pos = pos_in_line(each_line,key)
            # key所在每行对应的位置
            key_dict[count] = pos

    f.close()
    return key_dict

def search_files(key,detail):
    all_files = os.walk(os.getcwd())
    txt_files = []

    for i in all_files:
        for each_file in i[2]:
            if os.path.splitext(each_file)[1] == '.txt':
                each_file = os.path.join(i[0],each_file)
                txt_files.append(each_file)

    for each_txt in txt_files:
        key_dict = search_in_file(each_txt,key)
        if key_dict:
            print('============================')
            print('在文件【%s】中找到关键字【%s】'%(each_txt,key))
            if detail in ['YES','Yes','yes']:
                print_pos(key_dict)

key = input('请将该教本放于待查找的文件夹内，请输入关键字：')
detail = input('请问是否需要打印关键字【%s】在文件中的具体位置（yes/no）:'% key)
search_files(key,detail)