python基础
- 查看变量类型
- 查看变量地址
- 连续定义多个变量
- 交互式赋值定义变量
- 基本数学功能
- 在python中,可以对布尔值进行加减法运算.
- 数字类型转换
- 运算符
- 位运算符
- 关系运算符
- 逻辑运算符
- 成员运算符
- 身份运算符
- 字符串
- 字符串运算
- 字符串连接
- 字符串重复
- 访问字符串中某一个字符
- 字符串不可变
- 截取字符串
- 字符串比较大小
- 转义字符
- eval(str) 将字符串str当成有效的表达式来求值并返回计算结果
- len(str) 返回字符串的长度
- lower() 转换字符串中的大写字母为小写字母
- upper() 转换字符串中的大写字母为小写字母
- swapcase() 转换字符串中的大小写字母
- capitalize() 一句话的首字母大写
- title() 每个单词的首字母大写
- center(width, fillchar)
- count(string, start, end]) 在截取的[start, end)范围内,string在字符串中出现的次数
- find(string, start, end) 查找string在字符串中第一次出现的开始下标,没有则返回-1
- index(string, start=0, end=len(str)) 查找string在字符串中第一次出现的开始下标,没有则报错
- strip(string) 删除特定字符
- split(str=" ") 以str为分隔符分割字符串
- join() 以指定符组合字符串
- max() min()
- 替换
- 格式化输出
- 布尔值
- 空值
- list(列表)
- if语句
- while语句
- for语句
- turtle模块绘图
- tuple元组
- dict字典
- set
- 类型转换
- 迭代器
查看变量类型
type(a)
查看变量地址
id(a)
连续定义多个变量
num1 = num2 = num3 = 1
交互式赋值定义变量
num4, num5 = 6, 7 # num4 = 6 num5 = 7
基本数学功能
abs(-10) # 10 返回数字绝对值
max(1, 11) # 11 返回数字最大值
min(1, 11) # 1 返回数字最小值
pow(2, 10) 或 2 ** 10 # 1024 返回2的10次方
round(3.4) # 3 四舍五入
round(3.456, 2) # 3.46 保留小数点后2位数字
import math
math.ceil(18.1) # 19 向上取整
math.floor(18.9) # 18 向下取整
math.modf(18.9) # (0.9, 18) 返回整数部分和小数部分
5 // 3 # 1 取整,返回除法结果的整数部分
math.sqrt(16) # 4.0 开方
import random
#随机选取序列中的一个元素
random.choice([1,3,5,7,9]) # 7
random.choice(“abcd”) # b “abcd” == [“a”, “b”, “c”, “d”]
#产生一个1~100之间的随机数
random.choice(range(100))+1
random.randrange(1, 100, 2) # 3 产生1~100,步长为2的随机数,所以这里只会产生奇数,范围是半开的,包含1,不包含100
random.randrange(100) # 从0~99随机选取,默认步长为1
random.random() #随机产生[0,1)之间的数(浮点数)
random.shuffle([1,2,3,4,5]) # 将序列所有元素随机排序
random.uniform(3,9) #随机产生一个实数,他在[3, 9]范围
在python中,可以对布尔值进行加减法运算.
#True会被看做 1 , False会被看做 0 :
a = True
b = False
print a + a # 2
print a - a # 0
print a + b # 1
print a - b # 1
数字类型转换
int(1.9)
float(1)
int(“123”)
#如果有其他无用字符会报错,例如int(“123abc”)
#+, - 只有作为正负号才有意义:
\quad \quad
int(“12-3”),这个会报错
\quad \quad
int("+123")不会报错
运算符
+、-、、/、%、**(pow)、//(除法取整)
\quad \quad
# 赋值运算符
+=、-=、=、/=、%=、**=、//=
\quad \quad
# 复合运算符
位运算符
print(5&7) # 101&111=101 转换成二进制,两个都为1才为1,按位与
print(5|7) # 101|111=111 转换成二进制,有一个为1就为1,按位或
print(5^7) # 101^111=101 转换成二进制,两个不同时为1,按位异或
print(~5) # -6 等价于(-5-1) 转换成二进制,按位取反
print(13>>2) #13的二进制右移2位,得到3
print(-13>>2) #-13的二进制右移2位,得到-4,这是因为保存的是补码
print(3<<2) #3的二进制左移2位,得到12
关系运算符
==、!=、>、<、>=、<=
逻辑运算符
表达式1 and 表达式2 #逻辑与
表达式1 or 表达式2 #逻辑或
not 表达式 #逻辑非
成员运算符
in: #如果在指定序列中找到值,返回True,否则返回False
not in: #如果在指定序列中没有找到值,返回True,否则返回False
身份运算符
is: #判断两个标识符是不是引用同一个对象
is not: #判断两个标识符是不是引用不同的对象
字符串
以单引号或双引号引起的任意文本
字符串运算
字符串连接
str1 = "good "
str2 = “boy”
str3 = str1 + str2 # good boy
字符串重复
str1 = "good "
str3 = str1 * 3 # good good good
访问字符串中某一个字符
通过索引下标查找字符,索引从0开始
str1 = "good "
print(str1[3]) # d
字符串不可变
str1 = "good "
str1[2] = “a” # 会报错,因为字符串不可变
截取字符串
str1 = “good boy!”
print(str1[2:7]) # od bo 这是半开区间[2,7),所以y没有被读取
从头截取的话,可以直接str1[:7],等价于str1[0:7]
从给定下标截取到结尾的话,可以直接str1[2:],如果超过,按到最后算
字符串比较大小
print(“bazzz”<“bcaaa”) #True 从第一个字符开始比较,谁的ASCII值大谁就大,如果相等会继续比较下面的字符
print(“msaaa” > “ms”) #True 后面的自动补"\0"
转义字符
\n #换行
\t #制表符
print(r"\n\t\") # \n\t\ 将引号内的认为是一个没有转义字符的字符串,可用于路径等
eval(str) 将字符串str当成有效的表达式来求值并返回计算结果
print(eval(“12-9”)) # 3
print(eval(“12a”)) # 报错
len(str) 返回字符串的长度
lower() 转换字符串中的大写字母为小写字母
str = “GOOD boy”
print(str.lower()) # good boy,注意str中还是大写的
upper() 转换字符串中的大写字母为小写字母
str = “GOOD boy”
print(str.upper()) # GOOD BOY,注意str中还是小写的
swapcase() 转换字符串中的大小写字母
str = “GOOD boy”
print(str.swapcase()) # good BOY,注意str不变
capitalize() 一句话的首字母大写
str = “GOOD boy”
print(str.capitalize()) # Good boy,一句话的首字母大写,注意str不变
title() 每个单词的首字母大写
str = “GOOD boy”
print(str.title()) # Good Boy,每个单词的首字母大写,注意str不变
center(width, fillchar)
str = “GOOD boy”
print(str.center(18,"*")) # *****GOOD boy*****,注意str不变
count(string, start, end]) 在截取的[start, end)范围内,string在字符串中出现的次数
str = “GOOD boy boy”
print(str.count(“boy”)) # 2
print(str.count(“boy”, 6, len(str))) # 1
find(string, start, end) 查找string在字符串中第一次出现的开始下标,没有则返回-1
str = “GOOD boy boy”
print(str.find(“boy”)) # 5
print(str.find(“boy”, 6, len(str))) # 9
index(string, start=0, end=len(str)) 查找string在字符串中第一次出现的开始下标,没有则报错
str = “GOOD boy boy”
print(str.index(“boy”)) # 5
strip(string) 删除特定字符
str = “Good boy”
print(str.strip("*")) # Good boy
split(str=" ") 以str为分隔符分割字符串
str1 = “goodmanhello”
print(str1.split("")) # [‘good’, ‘’, ‘man’, ‘’, ‘hello’]
print(str1.split("",2))
join() 以指定符组合字符串
str2 = [‘good’, ‘man’, ‘hello’]
print("—".join(str2)) # good—man—hello
max() min()
str3 = “sunck is a good man!z”
print(max(str3)) # z
print("–"+ min(str3)+"–") # – --,空格最小
替换
replace() 单词对应替换
str4 = “sunck is a good good man!”
print(str4.replace(“good”,“nice”,1)) # sunck is a nice good man!
print(str4.replace(“good”,“nice”)) # sunck is a nice nice man!
maketrans() 创建一个字符串映射表,一个字符一个字符对应转换
str5 = str.maketrans(“som”,“123”)
str6 = “sunck is a good good man!”
str7 = str6.translate(str5)
print(str7) # 1unck i1 a g22d g22d 3an!
格式化输出
num = 10
str = “good boy”
f = 0.2356
print(“num=”,num,", str=",str,", f=",f)
print(“num=%d, str=%s, f=%.4f” % (num,str,f)) #这两种方法都可以输出
布尔值
True、False
空值
None
list(列表)
列表名 = [列表选项1, 列表选项2, …, 列表选项n]
列表中元素数据可以是不同类型
list = [1, 2, “good”, True]
取值
列表名[下标] # 下标从0开始
print(list[1]) # 2
替换
list[1] = 200
列表合并
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = list1 + list2
print(list3) # [1, 2 3, 4, 5, 6]
列表重复
list1 = [1, 2, 3]
print(list1 * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
判断元素是否在列表中
list1 = [1, 2, 3]
print(3 in list1) # True
列表截取
list1 = [1, 2, 3, 4, 5]
print(list1[1:3]) # [2, 3] 这是因为截取范围是半开区间
print(list1[3:]) # [4, 5]
print(list1[:3]) # [1, 2, 3]
二维列表
list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list[1][1]) # 5
列表方法
append 在列表末尾添加新的元素
list = [1, 2, 3]
list.append(6)
print(list) # [1, 2, 3, 6]
print(list + [7, 8, 9]) # [1, 2, 3, 6, 7, 8, 9]
list.append([7, 8, 9])
print(list) # [1, 2, 3, 6, [7, 8, 9]]
extend 在列表末尾一次性追加另一个列表中的多个值
list = [1, 2, 3]
list.extend([6, 7, 8])
print(list) # [1, 2, 3, 6, 7, 8]
list.extend(6) # 会报错,因为要是列表
等价于 print(list + [9, 10]) # [1, 2, 3, 6, 7, 8, 9, 10]
insert 在给定下标处插入一个元素,原数据向后顺延
list = [1, 2, 3, 4, 5]
list.insert(2, 100)
print(list) # [1, 2, 100, 3, 4, 5]
list.insert(3, [100, 300])
print(list) # [1, 2, 100, [100, 300], 3, 4, 5]
删除元素
pop 这里是根据下标删
list = [1, 2, 3, 4, 5]
print(list.pop()) # 5 默认是删除下标-1,即最后一个元素,并返回该元素
print(list.pop(2)) # 3
print(list) # [1, 2, 4]
remove 这个是根据元素值删
list = [1, 2, 3, 4, 5, 2]
print(list.remove(2)) # [1, 3, 4, 5, 2] 删除列表中第一个匹配的元素
clear 清楚列表中所有元素
list = [1, 2, 3, 4, 5, 2]
print(list.clear()) # []
index 从列表中找出某元素第一个匹配的索引值
list = [1, 2, 3, 8, 11, 8]
print(list.index(8)) # 3
print(list.index(8,3,5)) # 3 从下标范围,[3,5),找该元素的下标
print(list.index(8,4,)) # 5 从下标范围,4到最后,找该元素的下标
len 列表中元素的个数
list = [1, 2, 3, 8, 11, 8]
print(len(list)) # 6
count 查看某个元素在列表中出现的次数
list = [1, 2, 3, 8, 11, 8]
print(list.count(8)) # 2
max 获取列表中最大值
list = [1, 2, 3, 8, 11, 8]
print(max(list)) # 11
min 获取列表中最小值
list = [1, 2, 3, 8, 11, 8]
print(min(list)) # 1
reverse 倒序
list = [1, 2, 3, 8, 11, 8]
list.reverse()
print(list) # [8, 11, 8, 3, 2, 1]
sort 排序 升序
list = [1, 2, 3, 8, 11, 8]
list.sort()
print(list) # [1, 2, 3, 8, 8, 11]
拷贝
浅拷贝 又叫引用拷贝
b = a 赋值引用,a 和 b 都指向同一个对象
list1 = [1, 2, 3, 8, 11, 8]
list2 = list1
list2[1] = 600
print(list1) # [1, 600, 3, 8, 11, 8]
print(list2) # [1, 600, 3, 8, 11, 8]
print(id(list1)) # 2741471265160
print(id(list2)) # 2741471265160
b = a.copy() a 和 b 是一个独立的对象,但他们的子对象还是指向统一对象(是引用)
list3 = [1, 2, 3, 8, [11, 8]]
list4 = list3.copy()
list4[4][1] = 100
list4[1] = 65
print(list3) # [1, 2, 3, 8, [11, 100]]
print(list4) # [1, 65, 3, 8, [11, 100]]
print(id(list3)) # 1595578729352
print(id(list4)) # 1595578729608
深度拷贝
b = copy.deepcopy(a) 深度拷贝, a 和 b 完全拷贝了父对象及其子对象,两者是完全独立的。
import copy
list5 = [1, 2, 3, 8, [11, 8]]
list6 = copy.deepcopy(list5)
list6[4][1] = 100
list6[1] = 65
print(list5) # [1, 2, 3, 8, [11, 8]]
print(list6) # [1, 65, 3, 8, [11, 100]]
print(id(list5)) # 1554629935816
print(id(list6)) # 1554629937480
将元组转成列表
list7 = list((1, 2, 3))
print(list7) # [1, 2, 3]
if语句
if 表达式:
\quad
语句1
else:
\quad
语句2
if 表达式1:
\quad
语句1
elif 表达式2:
\quad
语句2
……
elif 表达式n:
\quad
语句n
else:
\quad
语句e
while语句
while 表达式:
\quad
语句
while 表达式:
\quad
语句1
else:
\quad
语句2
for语句
for 变量名 in 集合:
\quad
语句
range()函数 列表生成器
range(5) # 0 1 2 3 4
range(2, 10, 3) # 2 5 8 从2开始到10,每个元素间隔3
enumerate() 同时得到下标和元素值
for index, m in enumerate([5, 12, 8]):
\quad
print(index, m)
输出结果: 0 5
\quad \quad \quad \quad
1 12
\quad \quad \quad \quad
2 8
break
continue
turtle模块绘图
是一个简单的绘图工具
提供一个小海龟,可以把它理解为一个机器人,只能听得懂有限的命令
注意:绘图窗口原点(0,0)在正中间,默认海龟的方向是右侧
import turtle
turtle.forward(100) # 向前移动100长度
turtle.backword(50) # 向后移动50长度
turtle.right(45) # 箭头向右转动45度
turtle.left(45) # 箭头向左转动45度
turtle.forward(100) # 然后再向前移动100长度
turtle.goto(-100,-200) # 到达指定坐标点
turtle.speed(10) # 笔绘制的速度
turtle.up() # 将笔抬起,这样移动不会绘图
turtle.down() # 将笔放下,这样移动能够绘图
turtle.setheading() # 改变海龟的朝向
turtle.pensize(10) # 笔画的粗细
turtle.pencolor(colorstr) # 笔画颜色
turtle.reset() # 恢复所有设置,清空窗口,重置turtle状态
turtle.clear() # 清空窗口,不会重置turtle
turtle.circle(50,steps=5) # 绘制一个5边型
turtle.circle(50,) # 绘制一个半径为50的圆
turtle.begin_fill()
turtle.fillcolor(“red”) # 填充颜色
turtle.circle(50,steps=5) # 绘制一个5边型
turtle.end_fill()
turtle.undo() # 撤销上一次的动作
turtle.hideturtle() # 隐藏箭头
turtle.showturtle() # 显示箭头
turtle.done() # 程序继续执行,即画完图窗口还在
tuple元组
- 本质上是一种有序集合
- 与列表非常相似
- 一旦初始化就不能修改
- 使用小括号
- 因为元组的不可变性,所以安全
创建空元组
tuple1 = ()
print(tuple1) # ()
创建带有元素的元组
元组中的元素的类型可以不同
tuple2 = (1, 2, 3, “good”, True)
定义只有一个元素的元组
tuple3 = (1, )
print(tuple3) # (1,)
print(type(tuple3)) # <class ‘tuple’>
元组元素的访问
元组名[下标]
下标从0开始
tuple4 = (1, 2, 3, 4, 5)
print(tuple4[2]) # 2
print(tuple4[5]) # 报错 下标超过范围(越界)
print(tuple4[-1]) # 5 获取最后一个元素
print(tuple4[-2]) # 4
print(tuple4[-5]) # 1
print(tuple4[-6]) # 报错,越界
修改元组
tuple5 = (1, 2, 3, 4, [5, 6, 7])
tuple5[0] = 100 # 报错,元组不能变
tuple5[-1] = [7, 8, 9] # 报错
tuple5[-1][0] = 200 # 这个改变list
print(tuple5) # (1, 2, 3, 4, [200, 6, 7])
print(tuple5[-1]) # <class ‘list’>
删除元组
tuple6 = (1, 2, 3)
del tuple6
print(tuple6) # name ‘tuple6’ is not defined,因为已经别删除
元组的操作
元组拼接
t7 = (1, 2, 3)
t8 = (4, 5, 6)
print(t7+t8) # (1, 2, 3, 4, 5, 6)
元组重复
t10 = (1, )
print(t10 * 3) # (1, 1, 1)
判断元素是否在元组中
t11 = (1, 2, 3)
print(4 in t11) # False
元组的截取
元组名[开始下标:结束下标]
t12 = (1, 2, 3, 4, 5, 6)
print(t12[2:5]) # (3, 4, 5)
二维元组
t13 = ((1, 2, 3), (4, 5, 6))
print(t13[1][2]) # 6
元组的方法
len()
max()
min()
将列表转成元组
list = [1, 2, 3]
t14 = tuple(list)
dict字典
使用键值(key-value)存储,具有极快的查找速度
字典是无序的
key的特性:
- 字典中的key必须唯一
- key必须是不可变对象
- 字符串、整数等都是不可变的,可以作为key
- list是可变的,不能作为key
与list比较(list与之相反):
- 查找和插入的速度极快,不会随着key-value的增加而减慢
- 需要占用大量的内存,内存浪费多
字典创建
保存多名学生的姓名与成绩
使用字典,学生姓名为key,学生成绩为值
dict1 = {“tom”:60, “lilei”:70}
元素的访问
字典名[key]
print(dict1[“tom”]) # 60
print(dict1[“sunck”]) # 不存在,报错
print(dict1.get(“sunck”)) # None 不存在则返回None,不会报错
添加
dict1[“mzp”] = 99 # mzp不存在,则添加
修改
dict[“tom”] = 80 # tom存在,则修改
删除
dict1.pop(“tom”)
遍历
- for key in dict1:
\quad print(key, dict1[key])
输出: \quad tom 60
\quad \quad \quad lilei 70 - print(dict1.values()) # 输出:dict_values([60, 70])
for value in dict1.vlaues():
\quad print(value )
输出: 60
\quad \quad 70 - for k, v in dict1.items():
\quad print(k, v)
输出: \quad tom 60
\quad \quad \quad lilei 70 - for i, v2 in enumerate(dict1):
\quad print(i, v2)
输出:0 tom
\quad \quad 1 lilei
注意:dict实际上是无序的
统计
str1 = “Accumulate a little every day, and stick to it. Accumulate a little every day, and stick to it. Accumulate a little every day, and stick to it. Accumulate a little every day, and stick to it. Accumulate a little every day, and stick to it. Accumulate a little every day, and stick to it.”
统计单词出现次数
- print(str1.count("every ")) # 6
- d = {}
w = str1.split(" ") # 以空格划分
for v in w:
\quad c = d.get(v) # 从字典中提取,如果没有就将元素添加进字典
\quad if c == None:
\quad \quad d[v] = 1
\quad else:
\quad \quad d[v] +=1
print(d)
输出:
{‘it.’: 6, ‘Accumulate’: 6, ‘to’: 6, ‘day,’: 6, ‘stick’: 6, ‘a’: 6, ‘and’: 6, ‘every’: 6, ‘little’: 6}
set
类似于dict,是一组key的集合,不存储value,没有索引
本质是无序和无重复元素的集合
创建
创建set需要一个list或者tuple或者dict作为输入集合
s1 = set([1, 2, 3, 4, 5, 3, 4, 5]) # list 转 set
print(s1) # {1, 2, 3, 4, 5, 6}
s2 = set((1, 2, 3, 3, 2, 1)) # tuple 转 set
print(s2) # {1, 2, 3}
s3 = set({1:“good”, 2:“nice”}) # dict 转 set
print(s3) # {1, 2}
添加
s4 = set([1, 2, 3, 4, 5])
s4.add(6)
s4.add(3) # 可以重复添加,但是不会有效果
s4.add((7, 8, 9))
print(s4) # {1, 2, 3, 4, 5, 6, (7, 8, 9)}
s4.add([7, 8, 9]) # 报错,set的元素不能是列表,因为列表是可变的
s4.add({1:“a”}) # 报错,set的元素不能是字典,因为字典是可变的
#插入整个list、tuple、字符串,打碎插入
s5 = set([1, 2, 3, 4])
s5.update([5, 6, 7])
s5.update((8, 9))
s5.update(“nice”)
print(s5) # {1, 2, 3, 4, 5, 6, 7, 8, 9, ‘i’, ‘c’, ‘n’, ‘e’}
删除
s6 = set([1, 2, 4, 5, 6])
s6.remove(4)
print(s6) # {1, 2, 5, 6}
交集、并集
s7 = set([1, 2, 3])
s8 = set([2, 3, 4])
s9 = s7 & s8
print(s9) # {2, 3} 交集
s10 = s7 | s8
print(s10) # {1, 2, 3, 4} 并集
类型转换
#set–>list
s1 = {1, 2, 3, 4}
l1 = list(s1)
#set–>tuple
s2 = {2, 3, 4, 5}
t2 = tuple(s2)
迭代器
可迭代对象:可以直接作用于for循环的对象统称为可迭代对象(Iterable)。可以用isinstance()去判断一个对象是否是Iterable对象。
- 可直接作用于for的数据类型一般分为两种:
1、集合数据类型,如list、tuple、dict、set、string
2、是generator,包括生成器和带yield的generator function- 还可以被next()函数不断调用并返回下一个值,直到最后跑出一个StopIteration错误表示无法继续返回下一个值
endstr = “end”
str = “”
for line in iter(input, endstr):
\quad str += line + “\n”
print(str)
#这样就可以不断的输入,换行也不会结束,除非换行后输入“end”