初见Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
print()的使用
输出字符串或者数字 print(“wo”)print(22)
输出运算结果 print(25+25) 50
可以连接字符串 print(“lo”+”ve”) love
可输出多组数字或字符串，中间用“,”隔开。在输出端来看会在之间有空格
input()的使用
以换行作为结束标志
\n：换行
type()：用来判断数据类型
字符串：
single quotes: ‘aaa’
double quotes “aaa”  功能同上，当字符串中出现‘时，为能输出，就使用double。同理当字符串中有“时，可用single
当同时有‘和“时，可使用转义字符\
python中区分大小写
help()查看一个函数的帮助文档
原始字符串：用于输出函数中，使输出为原始的字符，不再转义，常用在输出地址的时候，例：print(r“D:\three\one\now”) 如果没有r，就需要转义每一个\，很麻烦
\在输出函数中，用来续行，例：print(“aaaa\n\
Bbbbb\n”) 这样b这行才能输出去


alt+p #重复上条代码


random.randint(1,10)


random.gatstate（）  #获取随机数生成器内部状态


random#函数默认用系统时间作为种子


random.setstate()#重新设置随机数生成器内部状态


#随机数重现
x＝random.getstate()
random.setstate(x)

#引入函数
import random
a=decimal.Decimal('0.1') #浮点数精确计算


#复数
1+2j
#以浮点数进行存储
#访问实部  x.real
#访问虚部  x.imag

#地板除  3//2
#结果向下取整

X/y
X=（x//y）*y + x%y


#内置函数，divmod（x，y）
#返回x//y和x%y


#计算x的y次方  pow（x，y）or
x**y
pow（2，3，5）= 2**3%5

结果为False的类型
img

分支循环

if语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
'''
if condition:
    statement


if condition:
    statement
    //缩进决定所属关系
else:
    statement


if condition1:
    statement(s)
elif condition2:
    statement(s)
elif condition2:
    statement(s)


if condition1:
    statement(s)
elif condition2:
    statement(s)
elif condition2:
    statement(s)
else:
'''
#条件成立时执行的语句 if condition else 条件不成立时执行的语句


#长语句 用（）包围

print("""
  ______            _ 
 / _____)          | |
| /      ___   ___ | |
| |     / _ \ / _ \| |
| \____| |_| | |_| | |
 \______)___/ \___/|_|
                      
""")

while语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
while 3<4:
    balabala


#while else语句

day=1
while day<=7:
    answer = input("今天有好好学习吗")
    if answer != "有"
        break
    day += 1
else 
    print("很棒")
#用于判断循环是否走完

#九九乘法表
i=1
while i<=9:
    j=1
    while j<=i:
        print(j,"*",i,"=",i*j,end=" ")
        j+=1
    print()
    i+=1

for语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#for 变量 in 可迭代对象:
    #statement(s)


for each in "love china":
    print(each)

#while实现
i=0
while i<len("love china"):
    print("love china"[i])
    i+=1

'''range(stop)
range(start,stop)
range(start,stop,step)'''

列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#创建列表:
rhyme=[1,2,3,4,5,"你好"]

#遍历列表:
for each in rhyme:
    print(each)

#单个访问
rhyme[i]

#列表切片
rhyme[0:3]
rhyme[3:6]
rhyme[:3]
rhyme[3:]

rhyme[0:6:2]
rhyme[::2]

#倒序输出
rhyme[::-1]

列表的方法

增

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
heros=['钢铁侠','绿巨人']
heros.append('黑寡妇')
heros

heros.extend(['鹰眼','雷神'])
#extend()方法的参数必须是一个可迭代对象，新的内容是追加到原列表最后一个元素的后面

s=[1,2,3,4,5]
s[len(s):]=[6]

s[len(s):]=[7,8,9]

#insert(位置,元素)
s.insert(1,2)
#插入开头
s.insert(0,0)
#插入结尾
s.insert(len(s),6)

删

1
2
3
4
5
6
7
8
9
10
remove()
heros.remove('灭霸')
#存在多个匹配的元素只会删除第一个
#如果元素不存在，程序会报错

#单个清除
pop(位置)

#全部清除
clear()

改

1
2
3
4
5
6
7
heros[4]='钢铁侠'
heros[3:]=['武松','林冲']

nums=[3,1,9,6,8,3,5,3]
nums.sort()#从小到大排序
reverse()#列表翻转
nums.sort(reverse=True)#从大到小排序

查

1
2
3
4
5
6
7
8
9
nums.count()
nums.index()#查找第一个索引值
nums[nums.index()]=3#直接更改
index(data,start,end)
copy()#复制

#浅拷贝
numc1=nums.copy()
numc2=nums[:]

列表的运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
s=[1,2,3]
k=[4,5,7]
s+k
[1, 2, 3, 4, 5, 7]


s=[1,2,3]
s*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]


#嵌套列表
matrix=[[1,2,3],[4,5,6],[7,8,9]]
matrix=[[1,2,3],
        [4,5,6],
        [7,8,9]]

#访问嵌套列表
for i in matrix:
    for each in i:
        print(each,end=' ')
    print()

#索引
matrix[][]

#创建嵌套列表
A=[0]*3
for i in range(3):
    A[i]=[0]*3

#错误：B=[[0]*3]*3

#is运算符
s='yes'
y='yes'
s is y
>>>True

浅拷贝和深拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#浅拷贝
numc1=nums.copy()
numc2=nums[:]

#深拷贝,用于嵌套列表
x=[[1,2,3],[4,5,6],[7,8,9]]
y=x.copy()
x[1][1]=0#同时y[0][0]也被改变


#深拷贝：
import copy
x=[[1,2,3],[4,5,6],[7,8,9]]
y=copy.copy(x)#浅拷贝
y=copy.deepcopy(x)#深拷贝

img
img

列表的推导式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
oho=[1,2,3,4]
oho=[i*2 for i in oho]
#列表的推导式：
#oho [对元素的操作 for i in 可迭代对象]

#字符转Unicode编码
code = [ord(c) for c in "yes"]

matrix=[[1,2,3],
        [4,5,6],
        [7,8,9]]
#提取第二列元素
col2 = [row[1] for row in matrix]
#提取主对角线
diag = [matrix[i][i] for i in range(len(matrix))]
#提取副对角线
fu = [matrix[i][-i-1] for i in range(len(matrix))]

#嵌套列表
matrix=[[0]*3 for i in range(3)]

#if条件的列表推导式
even = [i for i in range(10) if i%2==0]

#找F开头的单词
words=['Great','Fish','Brilliant','Excellent','Fantastic']
Fwords=[i for i in words if i[0]=='F']

#嵌套列表展开
matrix=[[1,2,3],
        [4,5,6],
        [7,8,9]]
flatten=[col for row in matrix for col in row]

flatten=[]
for row in matrix:
    for col in row:
        flatten.append(col)

[[x,y] for x in range(10) if x%2==0 for y in range(10) if y%3==0]

元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
rhyme = (1,2,3,4,5,6,'你好')
rhyme = 1,2,3,4,5,6,'你好'
#元组内容不可变

#元组支持count()和index()方法

s=1,2,3
t=4,5,6
s+t
>>(1,2,3,4,5,6)

#嵌套元组
w=s,t

#不存在元组推导式

#生成一个元素的元组
x=(520,)

#打包和解包
t=(123,'yes',3.14)
x,y,z=t
#x=123,y='yes',z=3.14

#多重赋值
x,y=10,20
#实现逻辑
_=(10,20)
x,y=_

#可修改的元组
x=[1,2,3]
y=[4,5,6]
s=(x,y)

字符串

1
2
3
#判断回文数
x='12321'
'是回文数' if x==x[::-1] else '不是回文数'

大小写字母变化函数

1
2
3
4
5
6
7
x='I love china'
x.capitalize()#返回一个将首字母变成大写，其他变成小写的字符串，不改变原字符串
x.casefold()#返回一个全是小写的字符串，不改变原字符串
x.title()#返回一个每个单词首字母为大写的字符串，不改变原字符串
x.swapcase()#大小写翻转
x.upper()#全字母大写
x.lower()#全字母小写

左中右对齐函数

1
2
3
4
5
6
7
8
x='有内鬼，停止交易！'
x.center(15)#居中
x.ljust()#左对齐
x.rjust()#右对齐
#修改填充字符
x.center(15,'-')

x.zfiil()#0补全字符串

查找函数

1
2
3
4
5
6
7
8
9
#count(sub[,start[,end]])
x='上海自来水来自海上'
x.count('海')
x.count('海',0,7)
#find(sub[,start[,end]]) 从左往右找，找不到返回-1
#rfind(sub[,start[,end]]) 从右往左找

#index(sub[,start[,end]])从左往右找,找不到报错
#rindex(sub[,start[,end]])从左往右找

替换函数

1
2
3
4
5
6
7
8
9
10
11
#expandtabs([tabsize=8])将tab改为空格，返回新的字符串

#replace(old,new,count=-1)
'i love china'.replace('love','like')

#translate(table)
str.maketrans()#创建表格
table=str.maketrans('ABCDEFG','1234567')#人话：翻译本
'i love china'.translate(table)
'i love china'.translate(str.maketrans('ABCDEFG','1234567'))
str.maketrans('被翻译字符串','结果字符串','免翻译字符')

判断和检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#返回布尔类型的值

startswith('',start,end)#判断参数内容是否在起始位置
endswith('',start,end)#判断参数内容是否在末尾位置

#进阶
x='u love china'
if x.startswith(('u','i','t')):
    print('love china')


#判断字母开头是否为大写且其他为小写
istitle()

#判断字母是否全为大写
isupper()

#判断字母是否全为小写
islower()

#判断字符串是否全是字符
isalpha()

#判断是否为空白字符串
isspace()

#判断字符是否全是可打印的
isprintable()

#判断数字
isdecimal()
isdigit()
isnumeric()

isalnum()
{
    isalpha()
    isdecimal()
    isdigit()
    isnumeric() 
    #任意一个为真，结果为true
}

#判断字符串是否是一个合法的标识符（命名规则
isidentifier()

#判断字符串是否为python保留标识符
import keyword
keyword.iskeyword("if")

截取字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#区域删除字符串
'           左侧不留白'.lstrip()
'右侧不留白         '.rstrip()
'           左右不留白'         .strip()
#括号内可传入参数改变删除的单个字符

#删除特定字符串
removeprefix()#删除特定前缀
removesuffix()#删除特定后缀

#拆分和拼接
"www.ilovechina.com".patition(".")#从左到右找参数为分割符，返回三个元素的元组
"www.ilovechina.com".rpatition(".")#从右往左找参数为分割符，返回三个元素的元组

split(sep==None,maxsplit=-1)#默认按空格拆分，返回一个列表，maxsplit控制切的次数，-1为找到就切割
split(',')#从左往右切割，改变分割符
rsplit()#从右往左切割

"11\n22\n33".splitlines()#按行分割，参数true表示包含换行符，默认false不包含换行符

#join(iterable)
".".join(["www","china","com"])
>>>www.china.com

格式化字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
year = 2004
"我出生于{}年".format(year)
>>'我出生于2004年'

"2的平方是{},3的立方是{}".format(2*2,3*3*3)

"2的平方是{1},3的立方是{0}".format(2*2,3*3*3)#花括号内可改变参数顺序
>>'2的平方是27,3的立方是4'

#关键字方法
"我叫{name}，我爱{fav}".format(name="Eureka",fav="中国")

#输出花括号
"{}".format("{}")'
"{{}}".format()

#{位置索引:[[fill][align][sign][#][0][width][grouping_option][.precision][type]]}

#align
"{:^}".format(250)#冒号左边是索引，右边是格式化选项     位置索引:对齐方向和显示宽度
"{:^10}".format(250)#加宽度

"{:010}".format(520)#使用零填充感知正负号
>>"000000520"
"{:010}".format(-520)#使用零填充感知正负号
>>"-000000520"
#改变填充符号
"{:%10}"

#[grouping_option]
"{:,}".format(10000000)#逗号作为千分符

"{:.2f}".format(3.1415)
>>'3.14'
"{:.2g}".format(3.1415)
>>'3.1'

#[#]自动在二进制八进制十六进制数前增加标识

[align]

值 含义
‘<’ 强制字符串在可用空间内左对齐（默认）
‘>’ 强制字符串在可用空间内右对齐
‘=’ 强制将填充放置在符号（如果有）之后但在数字之前的位置（这适用于以“+000000120”的形式打印字符串
‘^’ 强制字符串在可用空间内居中

[sign]

值 含义
‘+’ 正数前面填正号，负数前面填负号
‘-‘ 只在负数前面添加负号
‘空格’ 正数前面添加空格，负数前面添负号

[.precision] 精度

  • 对于[type]设置为’f’或’F’的浮点数来说，是限定小数点后显示多少个数位
  • 对于[type]设置为’g’或’G’的浮点数来说，是限定小数点前后一共显示多少个数位
  • 对于非数字类型来说，限定的是最大字段的大小
  • 对于整数类型来说，则不允许使用[.precision]选项

[type] 决定了数据如何呈现

f-字符串

1
2
3
year=2004
F"我出生于{year}年"
>>'我出生于2004年'