Python基础

最新推荐文章于 2024-07-09 17:39:03 发布

原创最新推荐文章于 2024-07-09 17:39:03 发布 · 374 阅读

本内容遵循CC 4.0 BY-SA版权协议

变量名的命名原则

1、以_或字母开头
2、变量名以_、数字、字母组成
3、变量名大小写敏感
4、不能使用Python保留的关键字
Python变量的特点

1、使用变量前不需要声明
2、变量的类型不固定
3、Python变量是实际值的引用
数值类型

十进制：123、1_234_789
八进制：0o123、0o_1_234_567、0O_123
十六进制：0x123、0x_1_234_567、0X_BAD_BEEF
二进制：0b10、0b_0011_1100、0B_11000011

float(浮点数)：1.23、1_2_3.、.123、.1_2_3
指数表示：1.23e4、1.2_3E-4、0E0、1e+1_1

x=3,y=5
x//y => 0  除后取整
x%y  => 3  除后取余
divmod(y,x) => (1,2) 返回一个包含商和余数的元组
y**x  =>125  返回x的y次方
round(x/y) =>1

列表（list）

1、用来储存多个数据的数据结构
2、储存的数据是有序的，可使用位置索引
3、列表长度和元素都是可变的
4、可储存不同类型的数据

 //创建列表
 x=['one', 2, [3, 4], (5, 6)]
 //使用索引获取列表中的数据
 x[0]=> 'one'
 x[-1]=> (5, 6)
 //判断值是否存在于列表中
 2 in x => true

元组（tuple）
1、储存形式与列表相似
2、元素不可修改
3、长度不可改变

//创建元组
t1=(1, 2, 3, 4, 5)
t2='one', 2, [3, 4], (5, 6)
t3=tuple([1,2,3])
t2[2][0]=> 3
t2[-1][1]=> 6
//判断值是否存在于元组中
4 not in t3

列表/元组操作

通过切片获得新的列表/元组

[start:end:step]
start:起始索引，从0开始，-1表示结束
end：结束索引
step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]切片
x[1:3]=>[2, 3]			x[1:6:2]=>[2 ,4, 6]
x[ :4]=>[1, 2, 3, 4]	x[-1:-8:-3]=>[0, 7, 4]

遍历列表/元组中的元素

Python中要求强制缩进以区分层次和代码块
缩进可以使用2个空格、4个空格、1个tab键实现
for  v  in  x:
    print(v)

zip()函数

>>> matrix = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11]]
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11)]

range类型
1、一段不可变的数字序列
2、经常被用作for里面来指定循环次数

//创建range对象:range(start, stop, step) start的默认值是0，step的默认值是1
range(4) =>0,1,2,3
range(4,1,-1) =>4,3,2

//range类型也支持切片
x=range(10)
x[1:3]=>range(1, 3)
x[6: ]=>range(6, 10)

//使用for循环遍历range()
for  v  in  range(10):
    print(v)

pack&unpack

pack:变量转换成序列
t = 1,2,3 =>t=(1, 2, 3)
unpack:序列转换成变量
a,b,c=t => a=1,b=2,c=3
unpack中使用*
a, b, *c = 1,2,3,4,5 => a=1, b=2, c=[3, 4, 5]
*a, b, c = 1,2,3,4,5 =>	a=[1, 2, 3], b=4, c=5
//交换两个变量的值
a, b = b, a

常见的序列操作

s = [1,2,3] t = [4,5,6] n = 2
s+t =>[1,2,3,4,5,6]
s*2 =>[1,2,3,1,2,3]
s.index(2) =>1
t.count(4) =>1  序列x元素出现的次数
s[2]=6 => s=[1,2,6] 更新指定索引的值
s[1:2]=t => s=[1, 4, 5, 6, 3] 使用序列t替换s中的i到j的值
del s[0:2] => s=[3] 等同于s[i:j] = []  （左闭右开）
s.append(4) => s=[1,2,3,4] 将值x添加到序列的末尾
s.append(t) => s=[1, 2, 3, 4, [4, 5, 6]]
s.extend(t) => s=[1, 2, 3, 4, 5, 6] 使用序列t扩展序列s
t.insert(0,7)=> t=[7, 4, 5, 6] 在序列s的i索引处插入值x
s.pop(1) => 2 ,s=[1,3] 返回序列s中索引为i的值，并将该值从序列中移除

Set（集合）
1、集合中保存的数据具有唯一性，不可重复
2、集合中保存的数据是无序的
3、往集合中添加重复数据，集合将只保留一个

//创建一个集合
 a=set()   空集合
 b={1,2,3} 非空集合
 
//集合操作
a={1, 2, 3} b={2, 3, 4} c={4, 5, 6}
a|b|c 或 a.union(b, c) =>{1, 2, 3, 4, 5, 6} 并集
a&b&c 或 a.intersection(b, c) =>set()  交集
a-b-c 或 a.difference(b, c) => {1}  差集

a.issuperset(b) 判断是否是超集
a.issubset(b)   判断是否是子集
a.isdisjoint(b) 判断两个集合是否相交

字典（Dict）
1、通过键值对（key-value）来储存数据
2、储存的数据是无序的，可使用键索引
3、键是必须唯一，但值可以不唯一
4、键的类型只能是字符串、数字或元组，值可以是任何

//创建字典
dict_1 = {} 
dict_2 = {1:'one', 2:'two', 3:'three'}
dict_3 = dict(one=1, two=2, three=3)
//获取字典中的值
dict_2[1] =>'one' 
dict_2.get(4,'four') =>'four'

//遍历字典的键
for k in x: #x.keys()
    print(k)
//遍历字典的值
for v in x.values():
    print(v)
//遍历字典的键和值
for k,v in x.items():
    print(k,v)

字符串
单引号、双引号、三引号（允许字符串换行）

x='Hello World'
x[0:5]='Hello'
int("123")  字符串转数值类型
float("123")
str(123)    数值类型转字符串
str(123.456)
ord('A') =>  65  字符转Unicode码
chr(65)  => 'A'  Unicode码转字符
x.split() => ['Hello', 'World'] list类型
s = '++'  s.join('why')  => 'w++h++y'
x.startswith('He')  =>true 
x.endswith('rl',1,-1) =>true 
x.replace(' ','-') => 'Hello-World'
x.count('o') =>2
x.find('llo') => 2 找不到子串时返回-1
x.index(' ') => 5 找不到子串时抛出异常