python基础一

查看变量类型

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”