Python初学者总结

这是一个社科学生python考试前夕写的，可能会存在错误，多多见谅！QAQ

input():

多个数字输入：

a,b = eval(input())

多个变量输入

a,b = input().split(',') 

使用’,’的原因是一般输入使用英文逗号分割变量

print()

print(str,end='')

---

变量与常量：

数据类型转换

int（）

去掉小数部分 & 把字符串变为数值(字符串中必须为整数)

print(int(1.3),int(-1.3),int('12'))

1 -1 12 # 输出 

float()

变为小数

print(float(1),float(2.3))

1.0 2.3 # 输出 

chr() & ord() 编码转换

print(ord('a'),chr(65))

97 A # 输出

关键字

import keyword
print(keyword.kwlist)
[
'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class','continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global','if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return','try', 'while', 'with', 'yield'
]

运算符：

算数运算符：

+,-   *,/,//,%    

** 优先级从右往左

比较运算符

==,！=,<,<=,>,>=

逻辑运算符

and，not,or

位运算符

赋值运算符 a+=1

优先级：算数>位>比较>赋值>逻辑

math

ceil() & floor() 向上取整 & 向下取整

import math
print(math.ceil(2.3),math.floor(2.5))

3 2 # 输出

sqrt()

开平方 == **（1/2）

print(math.sqrt(4))

2.0 # 输出 

pow(x,y)

x的y次方

print(math.pow(2,3))

8.0 # 输出 

round(a,b) 对a保留b位小数

print(round(2.23333333,3))

2.233 # 输出 

转义字符

\为换行 \\为
单引号为\‘ 双引号为\“
换行\n,制表\t,光标回到初始\r,后退\b,换页\f

循环：for-else结构

如果循环中break没有触发，就跳转到else

---

turtle

import turtle as t
t.setup(width=100,height=100,startx=10,starty=10) # 窗体大小
t.goto(100,100) # 位置运动
t.fd(10)forward
t.bk(10)back
t.circle(r=4,extent=None)# r半径，extent角度，默认360.圆心在左侧r距离位置
t.setheading(angle=30) # 绝对角度
t.left(90)
t.right(90)
t.penup()# 抬起
t.pendown()# 放下
t.pensize(10) # 画笔宽度
t.pencolor('red')# 颜色字符串
t.speed(10)# 速度

---

jieba

精确模式

jieba.lcut('中华人民共和国是一个伟大的国家') #cut_all默认为False，无冗余部分

['中华人民共和国','是','一个','伟大','的','国家'] # 输出

全模式

jieba.lcut('中华人民共和国是一个伟大的国家'，cut_all=Ture) #冗余从第一个字到最后一个字将所有可能的词语切分出来

['中华','中华人民','中华人民共和国','华人','人民','人民共和国','共和国','国是','一个','伟大,'的','国家'] # 输出

搜索引擎模式

jieba.lcut_for_search('中华人民共和国是一个伟大的国家') #将精确模式的长词进行全模式的切分

['中华','华人','人民','共和','共和国','中华人民共和国','是','一个','伟大','的','国家'] #输出

---

random

random.seed()

设定固定种子

random.randiant(a,b)

随机生成a,b之间的整数（闭区间）

random.random()

生成0.0到1.0之间的随机小数，左闭右开

random.uniform(a,b)

生成之间的随机小数（闭区间）

random.shuffle(seq)

将序列中的元素随机排序，返回打乱后的序列 （没有返回值）

import random
seq = [1,2,3,4,5]
random.shuffle(seq)
print(seq)

[4, 5, 3, 2, 1] #输出

random.choice(seq)

从序列中随机返回一个元素

---

异常处理 try-ecept

异常类：

• NameError 未声明变量

• SybtaxError 语法错误

try:
    pass 要执行的语句
except NameError: 异常类型一，可以不填，只有一个except也可以
    pass 解决方法
except SyntaxError:
    pass
except:
    pass
else: 无异常发生时执行的语句块
    pass
finally: 无论是否发生异常都要执行的语句块
    pass

---

字符串

索引

从零开始

切片 str[start,end,step]

(即使start和end为负数也要从左往右,start从零开始，end不能取)

s1 = 'zhencheng'
print(s1[::-1],s1[-6:-1],s1[7:1:-1])

gnehcnehz nchen nehcne #输出

*字符串拼接‘+’与复制‘’

成员运算符：in & not in

内置函数：len(),chr(),ord(),str()

大小写转换 str.lower(),str.upper()

数量检验 str.count(sub,start,end)

print('zhencheng'.count('en',2,6))

1 #输出

替换 str.replace(old,new,count)

前count次的old会被替换

print('11shuai,11hao,11bang'.replace('11','zhencheng',2))

zhenchengshuai,zhenchenghao,11bang #输出 

拼接 str.join(iterable)

iterable组合数据类型 这里要拼接的元素必须是字符串类型

print('-'.join(['1','2','3','4'])

1-2-3-4 # 输出 

切割 str.split(‘a’)

以a为基准进行切割，返回列表

print('a1b1c1d1'.split('1'))

['a', 'b', 'c', 'd', ''] #输出

搜索 str.find(sub,start,end)

end默认全字符串长度,给出end则不包含。如果有，就返回第一个索引。没有就返回-1

#案例1
print('zhenggggcheng'.find('g',3,9))

4 # 输出 

#案例2
print('zhengcheng'.find('q'))

-1 #输出 

index （sub）

与find相同。区别在于，find搜索的字串如果不存在，返回1；index则会报错。

format

从左往右依次为： 1.参数序号2.’:’引导符号3.填充符号4.对齐符号5.宽度6.’,’千位分割号7.精度8.数据类型

# 案例1
print('{:^10,}'.format(10000))

10,000 #输出

# 案例2
print('{:.1f}'.format(2.111))

2.1 #输出 

---

列表：序列数据类型

索引&切片&’+’拼接

len(),count(),index()

字符串同理

min(),max()

最大最小值

ls.append(a)

末尾添加a

ls.pop(2)

弹出并返回索引的元素

s.insert(index，item)

在第几位插入一个新的元素

del 删除列表

删除后列表不存在

#案例1
ls = [1,2,3,4]
del ls
print(ls)

NameError: name 'ls' is not defined  #输出

#案例2
ls = [1,2,3,4]
del ls[1]
print(ls) 

[1, 3, 4] #输出 

ls.remove(a)

删除列表中a这个元素

ls.reverse()

反转,没有返回值 与ls[::-1]相似

ls = [1,2,3,4]
ls.reverse()
print(ls)

[4, 3, 2, 1] #输出

ls.sort(key,reverse)

排序 key排序规则，reverse顺序 Ture是降序，False是升序，默认升序.没有返回值

ls=[1,3,2,4]
ls.sort(reverse=True)
print(ls)

[4, 3, 2, 1] #输出 

拓展： sorted(seq)有返回值（不修改原列表，创建新列表）

ls1=[1,3,2,4]
ls2=sorted(ls1)
print(ls2)

[1, 2, 3, 4] #输出

ls.clear（） 清空，无参数无返回值

ls.copy() 拷贝 有返回值

• 直接赋值，ls1=ls2,后面ls1会随着ls2变化而变化

• 浅拷贝：两个列表外层独立，内层关联

ls1=[1,2,[3,4]]
ls2=ls1.copy()
print('ls1:',ls1)
print('ls2:',ls2)
ls1[0]=666
print('ls1:',ls1)
print('ls2:',ls2)
ls1[2][0]=777
print('ls1:',ls1)
print('ls2:',ls2)

ls1: [1, 2, [3, 4]] #输出
ls2: [1, 2, [3, 4]]
ls1: [666, 2, [3, 4]]
ls2: [1, 2, [3, 4]]
ls1: [666, 2, [777, 4]]
ls2: [1, 2, [777, 4]]

• 深拷贝：完全独立

import copy
ls1=[1,2,[3,4]]
ls2=copy.deepcopy(ls1)
print('ls1:',ls1)
print('ls2:',ls2)
ls1[0]=666
print('ls1:',ls1)
print('ls2:',ls2)
ls1[2][0]=777
print('ls1:',ls1)
print('ls2:',ls2)

ls1: [1, 2, [3, 4]] #输出
ls2: [1, 2, [3, 4]]
ls1: [666, 2, [3, 4]]
ls2: [1, 2, [3, 4]]
ls1: [666, 2, [777, 4]]
ls2: [1, 2, [3, 4]]

ls.strip() 去掉两端的制表，换行

元组tuple

不可变的列表。元组类型的对象不支持重新定义

元组如果只有一个元素,需要在末尾添加一个逗号

t = (“haha”,) 这里是元组

t = (1,2,3,[“hahaha”,”momoda”])

元组不可变说的是表面内存地址不可变，但里面的列表可变 如： t[3].append(“hhh”)

元组顺序可变tuple[::-1]

---

集合set 无序，不可重复

s = {} 只放一个大括号会被认为是字典

形式

s = {1,2,3,”haha”} 这是集合的形式，但是不能有【】列表，不可哈希（unhashable）：
python中的set集合进行数据存储时，需要对数据进行哈希计算，根据据算出来的哈希值进行储存数据

元组可以放进去

可哈希：不可变的数据类型：int（数值），str，tuple（元组），bool
不可哈希：list（列表），dict（字典），set（集合）。因此set集合不存在嵌套问题。

运算

s1 = {"a","b","c"}
s2 = {"a","d","e"}
print(s1 & s2) # 交集
print(s1 | s2) # 并集
print(s1 - s2) # 差集

重要作用，可以去除重复

lst  = [a,b,a,c,]
set(lst)# 可以把列表重复的合并
list(set(lst))# 可以变回列表，但是可能会无序的结果

字典

空字典 dic = dict()

修改或者添加 dics[key]=value

dic = {‘a’:1,’b’:2,’c’:3}

返回所有key n = dic.keys

print(dic.keys())

dict_keys(['a', 'b', 'c']) #输出

返回values n = dic.values()

 print(dic.values())

dict_values([1, 2, 3]) #输出

返回所有键值对 n = dic.items()

 print(dic.items())

 dict_items([('a', 1), ('b', 2), ('c', 3)]) # 输出 

dic.get(key,value)

key 为指定键值，value为可选参数。若键值不存在就返回value（设定的默认值）或none（默认值）

# 案例1
dic = {'a':1,'b':2,'c':3}
print(dic.get('a'))

1 #输出

# 案例2
print(dic.get('e'))

None # 输出 

# 案例3
print(dic.get('f',6))

6 # 输出 

区别：dic[key]如果不存在会报错

dic.pop(‘a’，default)

键存在就返回值，同时删除键对.如果不指定键会删除最后一个并返回值。

dic = {'a':1,'b':2,'c':3}
v1 = dic.pop('a')
v2 = dic.pop('e',4)
print(v1,v2)

1 4 # 输出

dic.popitem() 删除最后一项并以元组形式返回键值对

清空 dic.clear()

消除后者存在 del dic

删除某一个键对值 del dic[key]

解包

元组，列表都可以用。解包，解构。

dic = {'a':1,'b':2,'c':3}
for key,value in dic.items():
    print(key,value)

a 1
b 2
c 3 # 输出

dic1.update(dic2)

新字典更新到就字典中，如果键重复，新的覆盖旧的；如果键不存在，直接添加

dic1 = {'a':1,'b':2,'c':3}
dic2 = {'r':34,'v':5,'c':6}
dic1.update(dic2)
print(dic1)

{'a': 1, 'b': 2, 'c': 6, 'r': 34, 'v': 5} # 输出

---

文件管理：

open(文件路径,mode=””,encoding=””)

mode

r:read w:write a:append(追加模式，用a去写入，不会删除原来文件内的内容) b:bytes(读写非文本的文件)，在前三个后面加上b

文件路径：

• 相对路径：相对与程序所在的文件夹。

• 绝对路径：d：/test/xxx.xx

open（”../“）返回上层文件

open("../葫芦娃.text")
open("../代码/倚天屠龙记.text")

with:上下文不需要手动关闭

with open('123.txt',mode="r",encoding="utf-8") as f: f = open()
    for line in f:
        print(line.strip)

with open('123.jpeg',mode = 'rb') as f:
    for line in f:
        print(line)

read

• 全部读取，不适用大文件

content = f.read()
print(content)

• 读取一行（这是第一行）

如果文本后面有/n，python会自动添加换行符，会显示换两行，可用content=f.readline.strip()

line = f.readline()
print(line)

• 输出多行，输出所有换行符等隐藏字符，放到列表中

content = f.readlines()
print(content)

write

f = open("123.txt",mode = "w",encoding="utf-8")# 大部分时候要把open放到循环外

如果文件不存在，自动创建
每一次open都会清空文件中的内容
f.write(‘1234’)
f.close() 养成好习惯，写入文件中。

文件的复制

with open('123.jpeg',mode = 'rb') as f1,\
     open('../sadj/asd/234.jpeg',mode = 'wb') as f2:
     for line in f1:
        f2.write(line)
with open('123.txt',mode='r',encoding='utf-8') as f1,\
     open('123_1.txt',mode='w',encoding='utf-8') as f2:
        for line in f1:
            line = line.strip()
            if line.starswith('1'):
                line = line.replace('1','2')
            f2.write(line)
            f2.write('\n')

---

函数

形参

• 位置参数

• 默认值参数

• 动态传参

*args表示接受的位置参数的动态传参 **kwargs传参，接受的所有参数都放入字典
print(food) 表示接受所有的关键字的动态传参

def chi(*food):#接收到的值会放在元组里
    print(food)
chi(1,2,3,4,5)

def chi(**food):表示接受关键字的动态

chi(fu = '1',zhu = '2')

顺序：位置参数，*args，默认值参数（修改可以写为 默认值=‘新’），**kwargs，

def func(*arge):
    print(arge)
lst = [1,2,3,4,5,6,7]
func(*lst)  #在实参位置把列表打散成位置参数进行传递，字典是两个**

实参

• 位置参数

• 关键字参数

• 混合参数 顺序：位置，关键字

global与nonlocal

• global 在局部引入全局变量

• nonlocal 在局部引入局部变量，向外找一层，有就引入，没有继续找），直到全局（不包括全局）

闭包

• 让一个变量常驻和内存

• 避免全局变量被修改

def func():
    a = 10
    def inner:
        nonlocal a
        a+=1
        return a
    return inner