Phython基础知识笔记

close

python3.7.4中的关键字

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

输入和输出

print()

• 不带引号，让计算机读懂括号⾥的内容，打印最终的结果

  print(1+1)

  2

• 带单引号，计算机⽆须理解，原样复述引号中的内容

  print('秋水共长天一色')
  print('Let\'s go')

  秋水共长天一色
  Let's go

• 带双引号，作⽤和单引号⼀样；当打印内容中有单引号时，可以使⽤双引号

  print("Let's go")

  Let's go

• 带三引号，实现换行

  print('''python小课
        最好的python课程''')

  pyton小课
  最好的python课程

  采用转义字符"n"也可以换行

  input()

  name = input('请输入你的forchange ID：')
  area = int(input('请输入 %d 的面积，单位 ㎡ ：' % room_number))

转义字符

• \a #bell
• \b #backspace
• \f #换页
• \n #换行
• \r #回车, 将当前位置一到本行开头
• \t #水平制表符
• \v #垂直制表符
• \ #""
• \' #单引号
• \" #双引号
• \? #问号
• \0 #零, 空字符
• \ddd #1到3位八进制所代表的任意字符
• \xhh #1到2位十六进制所代表的任意字符

算数运算符

print(2+1) #加法

3

print(1-2) #加法

-1

print(1*2) #乘法

2

print(1/2) #除法

0.5

print(2**3) #幂(2^3)

8

print(10%3) #取模

1

print(10//3) #取整除

3

if...elif...else

if…elif…else #三个及其以上条件的判断

grade = 65
if 80 <= grade <=100:
    print('成绩优秀')
elif 60 <= grade < 80:
    print('成绩中等')
else :
    print('成绩差')

成绩中等

字符串

str.spilt() #返回⼀个由字符串内单词组成的列表

'1,2,3'.split() #逗号也算一个字符,共有5个有效字符

['1',',','2',',','3']

'1,2,3'.split(',') #逗号作为分隔符，共有3个有效字符

['1','2','3']

a=['c','a','t']
b=''
print(b.join(a))
c='-'
print(c.join(a))

cat
c-a-t

列表/字典/元组

列表

s = ['弘福寺','大兴善寺','青龙寺','卧龙寺']
print(s) #打印列表

['弘福寺','大兴善寺','青龙寺','卧龙寺']

print(len(s)) #打印列表的长度

4

print(type(s)) #打印列表的类型

<class 'list'>

print(s[3]) #打印列表s里面的第3个元素

卧龙寺

print(s[0:4]) #打印列表s中0,1,2,3的元素,取左不取右

['弘福寺','大兴善寺','青龙寺','卧龙寺']

print(s[1:3]) #打印列表s中1,2的元素,取左不取右

['大兴善寺','青龙寺']

print(s[1:]) #打印列表s中第1个和此后的元素

['大兴善寺','青龙寺','卧龙寺']

print(s[:2]) #打印列表s中第2个和此前的元素

['弘福寺','大兴善寺']

s.append('观音禅寺') #把数据'观音禅寺'添加到列表的尾部
print(s[4]) #打印列表s中的第4个元素(上一步新增的)

观音禅寺

a = s.pop(0) #把第1个元素删除，并返回该元素的值
a = s.pop()  #把最后一个元素删除，并返回该元素的值

list1 = [5, 6, 4]
list2 = [1, 8, 9]
list = list1+list2 #合并列表
list.sort() #列表排序

判断一个元素是否在列表中

list1 = ['1','2','3']
if '1' not in list1:
    do something

索引值回绕

list1 = ['红','绿','蓝']
print(list1[-1])

红

索引值

list1 = ['1','0','2','0']
print(list1.index('0')) #显示第一个匹配的元素的索引值

1

append用法

a = [] #创建一个空的列表
a.append('A') #一次只能append一个元素
a.append('B') #apppend要用小括号
print(a)

['A','B']

del用法

一次只能删除一个元素
list1 = ['1','2','3']
del list1[0]
print(list1)

['2','3']
index用法

num = [0,1,0,1,2]
print(num.index(1)) # 数字1首次出现的索引位置是list[1]
print(num.index(2)) # 数字2首次出现的索引位置是list[4]

1
4

字典

d = {'QQ':['甲','乙','丙'],123:['A','B','C'],'家':10000}

a = d['QQ'] #取出字典d中的'QQ'键的值，并把这个值赋值给变量a, a被赋值为列表['甲', '乙', '丙']
b = a[0] #取出列表a中的第0个索引, 也就是'甲'，并把这个值赋值给变量b
print(b) #打印变量b

甲

print(d[123][1]) #从嵌套中提取元素, d[123]提取出['A','B','C'], d[123][1]提取'B'

B

d['家'] =900 #改变字典中的值
print(d['家’])

900

d[3.1415926] = '圆周率' #给字典新增键和值
print(d)

{3.1415926:'圆周率','QQ':['甲','乙','丙'],123:['A','B','C'],'家':900}

直接取键和值

scores = {'语文':89, '数学':95, '英语':80}
sum_score = 0
for subject, score in scores.items():
    sum_score += score

字典数据的增加

group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙和尚'}
group['白龙马']='敖烈' #添加一对键值
del group['师父']
print(group)

{'大师兄': '孙行者', '二师兄': '猪八戒', '沙师弟': '沙和尚','白龙马': '敖烈'}

字典数据的删除

group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙和尚'}
del group['师父']
print(group)

{'大师兄': '孙行者', '二师兄': '猪八戒', '沙师弟': '沙和尚'}

dict.keys() # 提取字典中所有的键

group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙和尚'}
print(group.keys()) #打印出了所有字典的键，但是都是元组的形式

dict_keys(['师父', '大师兄', '二师兄', '沙师弟'])

group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙和尚'}
print(list(group.keys())) #通过list()函数将元组转化为列表的形式

['师父', '大师兄', '二师兄', '沙师弟']

dict.values() #提取字典中所有的值

group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙和尚'}
print(group.values())

dict_values(['唐三藏', '孙行者', '猪八戒', '沙和尚'])

dict.items() #提取字典中所有的键值对

group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙和尚'}
print(group.items())

dict_items([('师父', '唐三藏'), ('大师兄', '孙行者'), ('二师兄', '猪八戒'),
('沙师弟', '沙和尚')])

元组

tuple1 = ('A','B')
list2 = [('A','B'),('C','D'),('E','F')]
print(tuple1[0])
print(list2[1][1])

A
D

for循环和while循环

for循环

for i in range(3):
    print(i)

0
1
2

for i in range(13,15):
    print(i)

13
14

for i in range(0,10,3):
    print(i)

0
3
6
9

for i in [1,2]:
    print(i*5)

5
10

d = {'小明':'醋','小红':'油'}
for i in d:
    print(d[i])

醋
油

遍历字符串

for i in 'coding':
    print(i)

c
o
d
i
n
g

遍历列表

for i in ['for','change']
    print(i)

for
change

for…in dict: # 遍历字典的键

list = {1:'a',2:'b',3:'c'}
for i in list:
    print(i)

1
2
3

for…in dict.values(): #遍历字典的值

list = {1:'a',2:'b',3:'c'}
for i in list.values():
    print(i)

a
b
c

for…in dict.items(): #遍历字典的键值对

list = {1:'a',2:'b',3:'c'}
for k, v in list.items():
    print(k)
    print(v)

1
a
2
b
3
c

循环嵌套

for i in ['千与','千寻']: #首先遍历列表元素
    for t in i: #然后遍历元素(字符串)
        print(t)

千
与
千
寻

while循环

a=0
while a < 3:
    a+=1
    print(a)

1
2
3

使用总结

循环次数明确用for循环
循环次数不明确用while循环

break #搭配if使用, 从循环内部跳出
continue #搭配if使用，跳远到循环开头
pass #搭配if使用，本行语句什么也不做
else #用在循环语句之后，如果正常结束循环，就执行else语句(没有遇到break)
···

secret = 24
for i in range(3):
    guess = input('guess which number is my secret:')
    if  int(guess) ==secret:
        print('正确！你很棒哦。')  #输出结果
        break
    elif int(guess)>secret:
        print('你猜的太大了，请重新猜猜~')
    else:
        print('你猜的太小了，请重新猜猜~')
else:
    print('给你3次机会都猜不到，你失败了。')
···

布尔值和布尔运算

比较运算符

, <, >=, <=, ==, !=

真假判断
假的: False, 0, '', [], {}, None

真的: True, 5, 1.0, '苏东坡', [1,2,3], {1:'春风',2:'秋风'}

list = [1,2,3,4,5]
a = 1
dict = {'法国':'巴黎','日本':'东京','中国':'北京'}
b = '法国'

做一次布尔运算，判断“a是否在列表list之中”
print(bool(a in list))
print(bool(a not in list))
print(bool(b in dict))

True
False
True

以下打印结果都为假：
print (bool(False))
print (bool(0))
print (bool(''))
print (bool([]))
print (boo({}))
print (boo(None())

以下都为真:
print (bool(True))
print (bool(5))
print (bool(-3))
print (bool('abc'))
print (bool([1,2,3]))
print (bool({1:1,2:2}))

布尔运算符号
and, or, not, in, not in

值本身作为条件

假的	其他都是真的
False	True
0	5（任意整数）1.0（任意浮点数）
''（空字符串）	'编程'（字符串）
[]（空列表）	[1,2,3]
{}（空字典）	{1:'a',2:'b'}
None

比较运算符产生布尔值

运算符	释义	作用
==	等于	如果两侧的值相等，条件为真
!=	不等于	如果两侧的值不相等，条件为真
>	大于	如果左侧的值⼤于右侧，条件为真
<	小于	如果左侧的值⼤于右侧，条件为真
>=	小于等于	如果左侧的值⼤于或等于右侧，条件为真
<=	小于等于	如果左侧的值⼩于或等于右侧，条件为真

成员运算符产⽣布尔值

运算符	释义	作用
in	属于	如果值在指定序列里，条件为真
not in	不属于	如果值不在指定序列里，条件为真

逻辑运算符产生布尔值

运算符	释义	作用
and	且	连接两个布尔值，如果两个都为真，该条件才为真
or	或	连接两个布尔值，如果有1个为真，该条件即为真
not	非	反逻辑状态，a为True，not a则为False，反之亦然

标准输入和输出

标准输入

string = input('请输入字符或者字符串:') #输入字符或者字符串
number = int(input('请输入数字:')) #用input输入的都是字符或者字符串，需要用int或者float才能转换为数字

格式化字符串输出

print('xxxx')
print('血量：%s 攻击：%s' % (player_life,player_attack))
print('我的幸运数字是%d和%d' % (8,16))
print('【玩家】n血量：%sn攻击：%s' % (player_life,player_attack))
print('hello',end='')
print('world!')
print(' 低于平均成绩的有：{}'.format(scores2))

格式化输出:

• %s #字符串显示
• %f #浮点数显示
• %d #整数显示

format()格式化函数：str.format()

print('\n{}{}'.format('数字：',0))  # 优势1：不用担心用错类型码。
print('{}，{}'.format(0,1))  # 不设置指定位置时，默认按顺序对应。
print('{1}，{0}'.format(0,1))  # 优势2：当设置指定位置时，按指定的对应。
print('{0}，{1}，{0}'.format(0,1))  # 优势3：可多次调用format后的数据。
name2 =  'Python基础语法'
print('我正在学{}'.format(name2))  # format()函数也接受通过参数传入数据。

代码里头使用格式化字符串:

url_1 = 'http://www.boohee.com/food/group/{type}?page={page}'
for x in range(1, 4):
    for y in range(1, 4):
        real_url = url_1.format(type=x, page=y)
        work.put_nowait(real_url)
#通过两个for循环，能设置分类的数字和页数的数字。

模块与库

模块类型

1. 内置模块 #python官方组织编写和维护的模块
2. 自定义模块 # 自己写代码，然后将代码块保存为.py文件
3. 第三方模块 # 从自定义模块而来，代码写作者公开自己的代码 / 根据模块的组织形式的不同，也可分为单个模块组件、模块包、模块库

import time,random,numpy

time.sleep(2) #暂停2秒
random.randint(1,100) #随机生成一个1~100之间的数，含1和100
avg = numpy.mean(list)

函数库

random
list=['1','2','3']
random.choice(list) # 从1, 2, 3中随机选取一个

print(random.randint(1,10)) # 产生 1 到 10 的一个整数型随机数
print(random.random()) # 产生 0 到 1 之间的随机浮点数
print(random.uniform(1.1,5.4)) # 产生 1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print(random.choice('tomorrow')) # 从序列中随机选取一个元素
print(random.randrange(1,100,2)) # 生成从1到100的间隔为2的随机整数

time
time.sleep(1)

math
math.ceil(size/div)  #向上取整
math.round(size/div) #四舍五入
math.int(size/div)   #向下取整

模块和模块对象导入方法

import A #导入模块A

• 可以调用模块内函数和变量，但是必须通过【模块名.函数名()】和【模块名.变量名】的方式调用
• 创建类实例的时候，需要使⽤【实例名 = 模块名.类名()】进⾏创建，创建实例后调用类方法和属性可以使用【实例名.函数名()】和【实例名.变量名】

import A as a #导入模块A，并将模块A重新命名为a

• 调用模块中的类、函数和变量如上述操作一样

from A import B

• 导入模块A中的变量/函数/类
• 调用对象B中的函数和变量可以不加模块名

from A import B，C，D

• 导入模块A中的多个变量/函数/类

from A import *

• 导入模块A中的所有变量/函数/类
• 不过，一般情况下，我们不要为了图方便直接使用【from xx模块 import *】的形式。这是因为，模块.xx的调用形式能通过阅读代码一眼看出是在调用模块中的变量/函数/方法，而去掉模块.后代码就不是那么直观了

if __name__=="__main__":

• 当.py文件被直接运行时，if __name__=="__main__":之下的代码块将被运行
• 当.py文件以模块形式被导入时，if __name__=="__main__":之下的代码块不被运行

函数

函数的作用域

程序中的变量并不是在哪个位置都可以被使用的，使用权限决定于这个变量是在哪里赋值的。关于这个概念，目前我们只需要掌握下面两点即可：

第一点：一个在函数内部赋值的变量仅能在该函数内部使用（局部作用域），它们被称作【局部变量】，如cost()函数里的variable_cost。

第二点：在所有函数之外赋值的变量，可以在程序的任何位置使用（全局作用域），它们被称作【全局变量】，如第一行的rent。

在函数内部对变量加上global声明，作用域就变成全局
global variable_cost

函数定义

def 函数名(参数): #冒号不可以少
    函数体
    return 语句

默认参数

def  menu(appetizer, course, dessert = '绿豆沙'):
    print('一份开胃菜：' + appetizer)
    print('一份主食：' + course)
    print('一份甜品：' + dessert)

menu('话梅花生','牛肉拉面')
#因为已经默认将'绿豆沙'传递给dessert，调用时无须再传递。
menu('话梅花生','牛肉拉面','银耳羹') #银耳羹对应参数dessert

一份开胃菜：话梅花生
一份主食：牛肉拉面
一份甜品：绿豆沙
一份开胃菜：话梅花生
一份主食：牛肉拉面
一份甜品：银耳羹

不定长参数

def menu(*barbeque):
    return barbeque
order = menu('烤鸡翅','烤茄子','烤玉米')
#括号里的这几个值都会传递给参数barbeque
print(order)
print(type(order))

('烤鸡翅', '烤茄子', '烤玉米')
<class 'tuple'>

常见的print函数的参数就是不定长参数
print(*objects, sep = ' ', end = 'n', file = sys.stdout, flush = False) #第一个参数是不定长参数，其余4个参数是默认参数

print('金枪鱼', '三文鱼', '鲷鱼', sep = '+', end = '=?')

金枪鱼+三文鱼+鲷鱼=?

返回多个结果

# 采集信息的函数
def myinput():
    choice = input('请选择计算类型：（1-工时计算，2-人力计算）')
    if choice == '1':
        size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))
        number = int(input('请输入人力数量：（请输入整数）'))
        time = None #空数据
        return size,number,time
        # 这里返回的数据是一个元组

return

函数带有返回值（return）时，执行函数并打印后，打印值为函数的返回值（默认为元组形式输出），如下例子：

def A():
    a=1
    b=2
    return a,b
print(A())

结果返回元组(a,b)
若想返回列表形式，可将代码修改为以下形式：

def A():
    a=1
    b=2
    return [a,b]
print(A())

python内置函数

abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

对象，类和实例

• 类和实例都是对象，面向对象编程，就是面向类和实例编程
• 类指事物的种类
• 实例: 类的个例

class Computer:            # 创建类
    screen = True          # 创建类的属性 (即定义"是什么")
    def start(self):       # 创建实例方法, self代表实例化对象, def + 方法名(self)
        print('这是电脑')  # 方法具体的过程，(即定义"做什么")
inst = Computer() # 实例化类Computer, inst就是实例化对象
print(inst.screen)# 调用实例的属性screen
inst.start()      # 调用实例的方法start

也可以改写为如下:

class Computer:            # 创建类
    def __init__(self)# init方法中的代码无需显示调用，就可以自动执行
        screen = True      # 创建类的属性 (即定义"是什么")
        print('这是电脑')  # 方法具体的过程，(即定义"做什么")
inst = Computer() # 实例化类Computer, inst就是实例化对象
print(inst.screen)# 调用实例的属性screen

__str__函数

class A():
    def __init__(self,name):
        self.name=name
    def __str__(self):
        return '我是{}'.format(self.name)

a=A('Peter‘)
print(a)

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法，其中__str__方法需要返回一个字符串，当做这个对象的描写，也是实例化后便执行的方法。

object是根类，是所有类的始祖

class Book:
     def __init__(self, name, author, comment, state = 0):
        self.name = name
        self.author = author
        self.comment = comment
        self.state = state
 
# 创建一个Book类的子类 FictionBook
class FictionBook(Book):
    def __init__(self, name, author, comment, state = 0, type = '虚构类'):
        Book.__init__(self, name, author, comment, state = 0)
        self.type = type

    def __str__(self):
        status = '未借出'
        if self.state == 1:
            status = '已借出'
        return ('类型：{} 名称：《{}》 作者：{} 推荐语：{}\n状态：{} '.format(self.type, self.name, self.author, self.comment, status))
book = FictionBook('囚鸟','冯内古特','我们都是受困于时代的囚鸟')
print(book) # 由于有__str__，不需要显示调用        

注意上面的子类的方法__init__要把所有父类的参数再重复一遍

文件读写

文件读写三步骤

1. 打开⽂件
2. 读（写）⽂件
3. 关闭⽂件

打开⽂件语法

open(file, mode, encoding) #打开⽂件

f = open('/letter.txt', 'r', encoding = 'UTF-8')

with open() as... #使⽤这种⽅式打开⽂件，可以不使⽤f.close()关闭⽂件

with open('/letter.txt', 'r', encoding = 'UTF-8') as f:
    f.read()

读写模式mode

模式mode	操作	若不存在	是否覆盖
r	只能读不能写	报错	-
rb	二进制只读	报错	-
r+	可读可写	报错	是
rb+	二进制读写	报错	是
w	只能写不能读	创建⽂件	是
wb	二进制只写	创建⽂件	是
w+	可读可写	创建⽂件	是
wb+	二进制读写	创建⽂件	是
a	追加不能读	创建⽂件	否，追加写
ab	二进制追加不能读	创建⽂件	否，追加写
a+	可读可写	创建⽂件	否，追加写
ab+	二进制追加可读可写	创建⽂件	否，追加写

读写⽂件语法

read() #读取⽂件内容

with open('/letter.txt','r',encoding = 'UTF-8') as f:
content = f.read()
#以字符串的形式读取文件内容，将文件内容赋值给变量content

readlines() # 以列表的⽅式读取⽂件内容

with open('/letter.txt','r',encoding = 'UTF-8') as f:
content = f.readlines()
#以列表的形式读取文件内容，将文件内容赋值给变量content

write() #清空⽂件内容，并写⼊字符串⼊内容

with open('/letter.txt','r',encoding = 'UTF-8') as f:
f.write('python')

writelines() #清空⽂件内容，以列表的⽅式写⼊

with open('/letter.txt','r',encoding = 'UTF-8') as f:
f.write('python')

关闭⽂件语法

f.close()

csv文件读写的相关函数

reader() #读取csv文件的函数

import csv #导入csv模块
with open('letter.csv') as f:
    reader = csv.reader(f) #读取csv文件，将文件内容赋值到reader

writer() #将内容写入csv文件

writerow() #写入一行内容

writerows() #一次写入多行csv文件

import csv #导入csv模块
with open('letter.csv','w',newline = '') as f:
    writer = csv.writer(f) #写入csv文件
    writer.writerow(['python'，'编程']) #写入一行内容
    data = [['工作'，'更简单'],['为你','答疑解惑']]
    writer.writerows(data) #写入多行内容

异常处理

try:
except 1stError:
except 2ndError:

num = [1,2,0,3,1.5,'6']
for x in num:
    try:  # 尝试执行下列代码
        print (6/x)
    except ZeroDivisionError:
        print('0是不能做除数的！')
    except TypeError:  # 当报错信息为TypeError，执行下面的语句。
        print('被除数必须是整值或浮点数！')

• except(ZeroDivisionError,ValueError):
• except Exception:

字符和汉子的编码

ASCII码	英文大小写, 字符, 不支持汉字	美国标准, 英文只占用7bit,欧洲扩展到8bit
GB2312码,GBK码	支持了中文	GBK码是GB2312的升级, 占用16bit
Unicode码	支持国际语言	ASCII码前添加8个bit就是Unicode
UTF-8码	支持国际语言	是一种针对Unicode的可变长度字符编码，它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度，而当字符在ASCII码的范围时，就用一个字节表示，所以UTF-8还可以兼容ASCII编码

reference:

• Unicode 和 UTF-8 的区别
• Unicode与UTF-8的区别

排序

对列表进行排序

a= [1, 5, 3, 6, 2]
b = sorted(a)
print(b)

[1,2,3,5,6]

对元组构成的列表进行排序

a=[('b',4),('a',0),('c',2),('d',3)]
print(sorted(a,key=lamda x:x[0]) 
print(sorted(a,key=lamda x:x[1]) 
# lambda是一个隐函数，是固定写法，不要写成别的单词；x表示列表中的一个元素，在这里，表示一个元组，x只是临时起的一个名字，可以使用任意的名字；x[0]表示元组里的第一个元素，x[1]就是第二个元素；所以这句命令的意思就是按照列表中第一个元素排序

[('a',0),('b',4),('c',2),('d',3)]
[('a',0),('c',2),('d',3),('b',4)]

对字典进行排序

list = ['罗恩102\n', '哈利383\n', '赫敏570\n', '马尔福275\n']
for i in file_lines:  # i是字符串。
    name = i[:-4]  # 取出名字（注：字符串和列表一样，是通过偏移量来获取内部数据。）
    score = int(i[-4:-1])  # 取出成绩
    dict_scores[name]=score
print(dict_scores)

# 按照value(分数)从大到小排序
dicts = sorted(dict_scores.items(), key=lambda x:x[1], reverse = True)
print(dicts)
# 按照key(人名)从小到大排列
dicts = sorted(dict_scores.items(), key=lambda x:x[0])
print(dicts)

{'罗恩': 102, '哈利': 383, '赫敏': 570, '马尔福': 275}
[('赫敏', 570), ('哈利', 383), ('马尔福', 275), ('罗恩', 102)]
[('哈利', 383), ('罗恩', 102), ('赫敏', 570), ('马尔福', 275)]

网络资源

*. python官方网站
*. python中文网站
*. 廖雪峰的官方网站:http://www.liaoxuefeng.com/
里面有Git的使用和Python入门教程，写的相当好。推荐学习
*. python画图的库matplotlib
*. 用Python学数学相关教程、开源包推荐与下载
https://segmentfault.com/a/11...
*. Python的所有报错类型，有需要的话可以在这里查阅：
https://www.runoob.com/python...
*. 35个高级Python知识点总结
https://www.jianshu.com/p/2de...
*. Python可视化工具介绍——找到合适的库
https://www.jianshu.com/p/620...
*. 一款与Python深度集成的神器级IDE，让我们告别Excel表格
https://www.jianshu.com/p/c77...
*. Python 与 Excel 终于在一起了（Grid Studio）
https://www.jianshu.com/p/258...
*. Python 正则表达式（完整版）
https://www.jianshu.com/p/529...
*. python正则表达式从字符串中提取数字
https://blog.csdn.net/u010412...