前言

本文旨在记录学习python的过程，通过每一个部分的记录，来加强学习并回忆python的过程，内容较多，请准备好零食，慢慢享用。

1 python基本数据类型

• 1 int(x[.base]) 将x转换成一个整数
• 2 float(x) 将x转换成一浮点数
• 3 complex(x[.imag]) 创建一个复数
• 4 str(x) 将对象转化成一个字符串
• 5 repr(x) 将对象转化成表达式字符串
• 6 eval(x) 用来计算在字符串中有效的python表达式，并返回一个对象
• 7 tuple(x) 将序列转化成一个元组
• 8 list(x) 将序列转化成一个列表
• 9 set(x) 转化为可变集合
• 10 dict(x) 创建一个字典
• 11 frozenset(x) 转换为不可变集合
• 12 chr(x) 将整数转换为一个字符
• 13 ord(x) 将一个字符转换为它的整数值
• 14 hex(x) 将一个整数值转换为一个十六进制字符串
• 15 oct(x) 将一个整数值转换为一个八进制字符串

2 Python推倒式

Python推倒式是一种特殊的数据处理方式，可以从一个数组序列构建一个新的数据序列的结构体

2.1 列表推倒式

作用：用于数据初始化
语法：[表达式 for 变量 in 列表 (if 条件)]

# 计算30以内的被5整除的数
Mui = [i for i in range(30) if i%5==0]
print(Mui)

[0, 5, 10, 15, 20, 25]

# 过滤掉长度小于3的字符串，并将符合条件的转成大写
names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
newa_names = [name.upper() for name in names if len(name)>3]
print(newa_names)

['ALICE', 'JERRY', 'WENDY', 'SMITH']

2.2 字典推倒式

{ key_expr: value_expr for value in collection if condition }

# 使用字符串及其长度创建字典
listydemo = ['Google','Runoob','Taobao']
newdiact = {key: len(key) for key in listydemo}
print(newdiact)
print(type(newdiact))

{'Google': 6, 'Runoob': 6, 'Taobao': 6}
<class 'dict'>

2.3 集合推倒式

{ expression for item in Sequence if condition }

# 计算1，2，3的平方
setnew = { i**2 for i in (1,2,3)}
print(setnew)
# 输出不是abc的字符
a = [x for x in 'abcedfascnba' if x not in 'abc']
print(a)

{1, 4, 9}
['e', 'd', 'f', 's', 'n']

2.4 元组推倒式

元组推倒式可以利用range区间，元组，列表，字典和集合数据烈性，快速生成一个满足指定需求的元组
( expression: for item in Squence if condition )
元组推倒式和列表推倒式的用法完全相同，只是元组推倒式使用()表示，而列表推倒式使用[]表示，另外元组推倒式返回的结果是一个生成器对象

a = ( x for x in range(1,10))print(a)
print(tuple(a)) # tuple将生成器对象转化成元组

<generator object <genexpr> at 0x104c50dd0>
(1, 2, 3, 4, 5, 6, 7, 8, 9)

3 注释

'''
这是多行注释1
'''"""
这是多行注释2
"""# 这是单行注释

'\n这是多行注释2\n'

4 运算符

4.1 算数运算符

+ - * / % ** //

4.2 比较运算符

== ！= > < >= <=

4.3 赋值运算符

= += -= *= /= %= **= //=

4.4 位运算符

& | ^ ~ << >>

4.5 逻辑运算符

and ,or ,not

4.6 成员运算符

in , not in

4.7 身份运算符

is, is not

# id() 用于获取内容地址
# del 变量 可以删除变量内容及其地址
id(a)

4374990288

5 Number

5.1 数学函数

• 1 abs() 返回数字的绝对值
• 2 ceil() 返回数字的上入整数， 如math.cell(4.1)=5
• 3 exp() 返回e的x次幂，exe^xex
• 4 fabs() 返回数字的绝对值
• 5 floor() 返回数字的下舍整数，如math.floor(4.9)=4
• 6 log(x) logexlog_exloge​x
• 7 log10(x) log10xlog_{10}xlog10​x
• 8 max(x1,x2,…)
• 9 min(x1,x2,…)
• 10 modf() 返回数的整数部分与小数部分
• 11 pow() 幂运算
• 12 round(x,[.n]) 返回浮点数保留n位后的四舍五入值
• 13 sqrt() 返回数字的平方根

number1, number2, number3, number4, number5 = 10, 100, 1000, 5.5, -7.2

import math
math.fabs(number5)
math.log(math.e)
math.log10((number3))
math.ceil(number4)
math.floor(number4)
round(number4)
math.pow(4,2)
math.sqrt(64)
abs(number5)

7.2

5.2 随机数函数

choice(seq) 从序列中随机挑选一个元素
randrange(start ,stop) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认为1
random() 随机生成一个随机数，在（0，1）之间
seed() 改变随机数生成器的种子seed, 生成随机数固定
shuffle() 将序列所有元素随机排序
uniform(x,y) 随机生成下一个实数，在（x,y）内

import random
random.random()
random.randrange(1,10)
random.uniform(4,5)

4.0337696405212835

5.3 三角函数

• 1 acos() 反余弦
• 2 asin() 反正弦弧度
• 3 atan() 反正切弧度值
• 4 atan2(y,x) 反正切
• 5 cos() 余弦
• 6 hypot(x,y) 返回欧几里得范数，sqrt(xx+yy)
• 7 sin() 正弦
• 8 tan() 正切
• 9 degrees(x) 将弧度转化为角度
• 10 radians(x) 将角度转化为弧度

import math
math.hypot(3,4)
math.degrees(math.pi/2)
math.radians(45)

0.7853981633974483

6 字符串

6.1 字符串运算

• 1 + 连接
• 2 * 重复输出
• 3 [] 通过索引获取
• 4 [:] 获取字符串的额一部分，左闭右开原则
• 5 in 成员运算符，下同
• 6 not in
• 7 r/R 原始字符串
• 8 % 格式化字符串

# 格式化输出
print("i'm %s, %d years old"%('Lif',20))

i'm Lif, 20 years old

6.2 字符串格式化符号

符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

6.3 三引号

三引号可以跨行并保留格式显示内容

Str ="""12442412
3144ffsffsg;'\n'
fsfsdg,gdsgfdgg.g,,gdgd"""
print(Str)

12442412
3144ffsffsg;'
'
fsfsdg,gdsgfdgg.g,,gdgd

6.4 f-string

以f开头，后面跟着字符串， 字符串中的表达式使用{}包起来，它会将表达式计算后的值替换

f'{1+3}'

'4'

name = 'df'
f'hello, {name}'

'hello, df'

x=5
print(f'{x+5}')

10

6.5 字符串内建函数

序号 方法及描述

• 1 capitalize()
  将字符串的第一个字符转换为大写

• 2 center(width, fillchar)
  返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

• 3 count(str, beg= 0,end=len(string))
  返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

• 4 bytes.decode(encoding=“utf-8”, errors=“strict”)
  Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

• 5 encode(encoding=‘UTF-8’,errors=‘strict’)
  以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’

• 6 endswith(suffix, beg=0, end=len(string))
  检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

• 7 expandtabs(tabsize=8)
  把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

• 8 find(str, beg=0, end=len(string))
  检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

• 9 index(str, beg=0, end=len(string))
  跟find()方法一样，只不过如果str不在字符串中会报一个异常。

• 10 isalnum()
  如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False

• 11 isalpha()
  如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False

• 12 isdigit()
  如果字符串只包含数字则返回 True 否则返回 False…

• 13 islower()
  如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

• 14 isnumeric()
  如果字符串中只包含数字字符，则返回 True，否则返回 False

• 15 isspace()
  如果字符串中只包含空白，则返回 True，否则返回 False.

• 16 istitle()
  如果字符串是标题化的(见 title())则返回 True，否则返回 False
  17 isupper()
  如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

• 18 join(seq)
  以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

• 19 len(string)
  返回字符串长度

• 20 ljust(width[, fillchar])
  返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

• 21 lower()
  转换字符串中所有大写字符为小写.

• 22 lstrip()
  截掉字符串左边的空格或指定字符。

• 23 maketrans()
  创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

• 24 max(str)
  返回字符串 str 中最大的字母。

• 25 min(str)
  返回字符串 str 中最小的字母。

• 26 replace(old, new [, max])
  把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

• 27 rfind(str, beg=0,end=len(string))
  类似于 find()函数，不过是从右边开始查找.

• 28 rindex( str, beg=0, end=len(string))
  类似于 index()，不过是从右边开始.

• 29 rjust(width,[, fillchar])
  返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串

• 30 rstrip()
  删除字符串末尾的空格或指定字符。

• 31 split(str=“”, num=string.count(str))
  以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

• 32 splitlines([keepends])
  按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

• 33 startswith(substr, beg=0,end=len(string))
  检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

• 34 strip([chars])
  在字符串上执行 lstrip()和 rstrip()

• 35 swapcase()
  将字符串中大写转换为小写，小写转换为大写

• 36 title()
  返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

• 37 translate(table, deletechars=“”)
  根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

• 38 upper()
  转换字符串中的小写字母为大写

• 39 zfill (width)
  返回长度为 width 的字符串，原字符串右对齐，前面填充0

• 40 isdecimal()
  检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

Str = 'Hello everyone, good morning!'

Str.capitalize()

'Hello everyone, good morning!'

Str.count('e')

4

Str.find('r')

9

Str.title()

'Hello Everyone, Good Morning!'

Str.swapcase()

'hELLO EVERYONE, GOOD MORNING!'

7 list

7.1 访问

list1 = ['green','blue','pink','orange']
print(list1[1]) # 正序
print(list1[-2]) # 倒序
print(list1[:3]) # 切片，范围
print(list1[::-1]) # 反转输出

blue
pink
['green', 'blue', 'pink']
['orange', 'pink', 'blue', 'green']

7.2 脚本操作符

Python 表达式 结果 描述
len([1, 2, 3]) 3 长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
[‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 重复
3 in [1, 2, 3] True 元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代

7.3 列表函数&方法

序号 函数

• 1 len(list)
  列表元素个数
• 2 max(list)
  返回列表元素最大值
• 3 min(list)
  返回列表元素最小值
• 4 list(seq)
  将元组转换为列表

序号 方法

• 1 list.append(obj)
  在列表末尾添加新的对象
• 2 list.count(obj)
  统计某个元素在列表中出现的次数
• 3 list.extend(seq)
  在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
• 4 list.index(obj)
  从列表中找出某个值第一个匹配项的索引位置
• 5 list.insert(index, obj)
  将对象插入列表
• 6 list.pop([index=-1])
  移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
• 7 list.remove(obj)
  移除列表中某个值的第一个匹配项
• 8 list.reverse()
  反向列表中元素
• 9 list.sort( key=None, reverse=False)
  对原列表进行排序
• 10 list.clear()
  清空列表
• 11 list.copy()
  复制列表

list1.append('black')
print(list1,list1.count('green'),list1.index('green'),list1.insert(1,'red'))

['green', 'red', 'pink', 'orange', 'black', 'black', 'black', 'black', 'black'] 1 0 None

print(list1,list1.pop(2))
print(list1)

['green', 'red', 'orange', 'black', 'black', 'black', 'black', 'black'] pink
['green', 'red', 'orange', 'black', 'black', 'black', 'black', 'black']

8 Tuple

Tuple与list很相似，但是Tuple不能修改
元组使用（）表示。
元组可以使用索引访问，使用切片截取，但是不可以修改，可以拼接 使用del 删除，

8.1 元组运算符

序号 方法及描述 实例

• 1 len(tuple)
  计算元组元素个数。
  tuple1 = (‘Google’, ‘Runoob’, ‘Taobao’)
  len(tuple1)
• 2 max(tuple)
  返回元组中元素最大值。
  tuple2 = (‘5’, ‘4’, ‘8’)
  max(tuple2)
• 3 min(tuple)
  返回元组中元素最小值。
  tuple2 = (‘5’, ‘4’, ‘8’)
  min(tuple2)
• 4 tuple(iterable)
  将可迭代系列转换为元组。
  list1= [‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’]
  tuple1=tuple(list1)

9 dict

字典是另外一种容器类型，且可存储任意类型， 使用{}表示
字典包括键值对，其中键必须唯一，值可以不唯一，键不可变
字典可以使用键访问，可以使用del删除，可以修改

9.1 内置函数&方法

序号 函数及描述 实例

• 1 len(dict)
  计算字典元素个数，即键的总数。
  tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
  len(tinydict)
• 2 str(dict)
  输出字典，可以打印的字符串表示。
  tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
  str(tinydict)
  “{‘Name’: ‘Runoob’, ‘Class’: ‘First’, ‘Age’: 7}”
• 3 type(variable)
  返回输入的变量类型，如果变量是字典就返回字典类型。
  tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
  type(tinydict)
  <class ‘dict’>

---

序号 函数及描述

• 1 dict.clear()
  删除字典内所有元素
• 2 dict.copy()
  返回一个字典的浅复制
• 3 dict.fromkeys()
  创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
• 4 dict.get(key, default=None)
  返回指定键的值，如果键不在字典中返回 default 设置的默认值
• 5 key in dict
  如果键在字典dict里返回true，否则返回false
• 6 dict.items()
  以列表返回一个视图对象
• 7 dict.keys()
  返回一个视图对象
• 8 dict.setdefault(key, default=None)
  和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
• 9 dict.update(dict2)
  把字典dict2的键/值对更新到dict里
• 10 dict.values()
  返回一个视图对象
• 11 pop(key[,default])
  删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
• 12 popitem()
  返回并删除字典中的最后一对键和值。

dicts = {'1':123,'2':234,'3':345}
print(dicts)

{'1': 123, '2': 234, '3': 345}

dicts.get('2')

234

'3' in dicts

True

dicts.pop('2')

234

dicts.popitem()

('3', 345)

dicts.values()

dict_values([123, '2'])

dicts.keys()

dict_keys(['1', '4'])

dicts.items()

dict_items([('1', 123), ('4', '2')])

10 set

set是一个无序不重复的元素序列。
使用{}或者set()创建， 创建一个空集合必须使用set(),因为{}是用来创建空字典的

10.1 基本操作

添加add()或者update(parameter=list,tuple,dict…)
移除remove(x),不存在会报错，discard(x),不存在不会报错 pop()
len(), set.clear(), x in set

10.2 内置方法

方法 描述
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集
update() 给集合添加元素

11 条件控制

print("""
if condition:   block
elif condition:  block
else:  block
""")

if condition:   block
elif condition:  block
else:  block

12 循环

12.1 while循环

12.2 while 循环使用else语句

12.3 for循环 （for x in Sequence）

12.4 range()

12.5 break&continue

12.6 for…else…

12.7 pass

13 迭代器

迭代器很强大，是访问集合元素的一种方式
它可以记住遍历的位置对象
迭代器从第一个对象开始迭代，只会向前不会向后
有两个方法： iter(),next()
列表，元组，字符串均可以创建迭代器

it = iter(list1) # 创建一个迭代器对象
for i in it:print(i)

green
red
orange
black
black
black
black
black

14 函数

14.1 词法

def 函数名（参数列表）：
函数体

def 函数名（a,b,c=5 ）：
“如果参数列表存在默认参数，赋值不给，则默认使用”
函数体

def 函数名（args,*vartuple）:
“可变参数要放在最后，以元组形式传递进去”
函数体。
def 函数名（args,**vardict）:
“可变参数要放在最后，以字典形式传递进去”
函数体。

def hello():print("say hello")
def hello1(Str):print("%s say hello"%Str)

hello1('Li'),hello()

Li say hello
say hello
(None, None)

def Cal(a,b,c=5):return a+b+b*c

Cal(1,2),Cal(1,2,4)

(13, 11)

def Cal1(a,*b):s = 0print(*b)for i in b:s+=ireturn a*s

Cal1(2,3,3,4,4,5,5)

3 3 4 4 5 5
48

def Cal2(a, **dict):print(dict)print(dict.items())

Cal2(3,b=5,c=6)

{'b': 5, 'c': 6}
dict_items([('b', 5), ('c', 6)])

14.2 匿名函数

lambda表达式。
语法：lambda[arg1,[arg2,arg3,…,argn]]:expression

vv = lambda c : c**2
print(vv(3))

9

14.3 查看函数具体方法

使用dir(module)可以显示。

import math
dir(math)

['__doc__','__file__','__loader__','__name__','__package__','__spec__','acos','acosh','asin','asinh','atan','atan2','atanh','ceil','copysign','cos','cosh','degrees','e','erf','erfc','exp','expm1','fabs','factorial','floor','fmod','frexp','fsum','gamma','gcd','hypot','inf','isclose','isfinite','isinf','isnan','ldexp','lgamma','log','log10','log1p','log2','modf','nan','pi','pow','radians','remainder','sin','sinh','sqrt','tan','tanh','tau','trunc']

15 输入和输出

15.1 输入

输入input（）

input("str:")

str:sssss'sssss'

15.2 输出

输出格式美化

• 1 repr() 产生一个解释器易读的表达式
• 2 str() 产生一个用户易读的表达式
• 3 str.format()
• 4 str %

# 默认
print("hello {}, l'm {}".format("Lori","happy"))

hello Lori, l'm happy

# 指定位置
print("hello {1}, l'm {0}".format("Lori","happy"))

hello happy, l'm Lori

# 使用指定字符，并且可以混合使用
print("hello {1}, l'm {0}，{su}".format("Lori","happy", su="12345...."))

hello happy, l'm Lori，12345....

# !a 使用ascii(), !s使用str(), !r使用repr()
print("{!a}".format(math.e))

2.718281828459045

# 方法1
table = {'green':0, 'blue':1, 'red':2}

print("green:{0[green]:d}, blue:{0[blue]:d}, red:{0[red]:d}".format(table))

green:0, blue:1, red:2

print("green:{green:d}, blue:{blue:d}, red:{red:d}".format(**table))

green:0, blue:1, red:2

print("display is %8.20f"%math.e)

display is 2.71828182845904509080

15.3 读写文件

open(filename, mode)
mode不同模式打开文件的完全列表：
模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

# 实例写入一个文件
f = open("foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()

f = open("foo.txt", "r")
print(f.read())
# 关闭打开的文件
f.close()

Python 是一个非常好的语言。
是的，的确非常好!!

# readline()只读取一行
f = open("foo.txt", "r")
str = f.readline()
print(str)# 关闭打开的文件
f.close()

Python 是一个非常好的语言。

15.3.1 文件操作

f.tell()
f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

f.seek()
如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符

# readline()只读取一行
f = open("foo.txt", "r")
f.seek(6,0)
str = f.readline()
print(str)# 关闭打开的文件
f.close()

 是一个非常好的语言。

# readline()只读取一行
f = open("foo.txt", "r")
for r in f:print()
str = f.readline()
print(str)# 关闭打开的文件
f.close()

16 文件

open方法
完整的语法格式为：

open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明:

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

file 对象
file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

序号 方法及描述

• 1 file.close()
  关闭文件。关闭后文件不能再进行读写操作。

• 2 file.flush()
  刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

• 3 file.fileno()
  返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。

• 4 file.isatty()
  如果文件连接到一个终端设备返回 True，否则返回 False。

• 5 file.next()
  Python 3 中的 File 对象不支持 next() 方法。
  返回文件下一行。

• 6 file.read([size])
  从文件读取指定的字节数，如果未给定或为负则读取所有。

• 7 file.readline([size])
  读取整行，包括 “\n” 字符。

• 8 file.readlines([sizeint])
  读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。

• 9 file.seek(offset[, whence])
  移动文件读取指针到指定位置

• 10 file.tell()
  返回文件当前位置。

• 11 file.truncate([size])
  从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。

• 12 file.write(str)
  将字符串写入文件，返回的是写入的字符长度。

• 13 file.writelines(sequence)
  向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

17 OS

os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

序号 方法及描述
1 os.access(path, mode)
检验权限模式
2 os.chdir(path)
改变当前工作目录
3 os.chflags(path, flags)
设置路径的标记为数字标记。
4 os.chmod(path, mode)
更改权限
5 os.chown(path, uid, gid)
更改文件所有者
6 os.chroot(path)
改变当前进程的根目录
7 os.close(fd)
关闭文件描述符 fd
8 os.closerange(fd_low, fd_high)
关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9 os.dup(fd)
复制文件描述符 fd
10 os.dup2(fd, fd2)
将一个文件描述符 fd 复制到另一个 fd2
11 os.fchdir(fd)
通过文件描述符改变当前工作目录
12 os.fchmod(fd, mode)
改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13 os.fchown(fd, uid, gid)
修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14 os.fdatasync(fd)
强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15 os.fdopen(fd[, mode[, bufsize]])
通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16 os.fpathconf(fd, name)
返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17 os.fstat(fd)
返回文件描述符fd的状态，像stat()。
18 os.fstatvfs(fd)
返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19 os.fsync(fd)
强制将文件描述符为fd的文件写入硬盘。
20 os.ftruncate(fd, length)
裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21 os.getcwd()
返回当前工作目录
22 os.getcwdb()
返回一个当前工作目录的Unicode对象
23 os.isatty(fd)
如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24 os.lchflags(path, flags)
设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25 os.lchmod(path, mode)
修改连接文件权限
26 os.lchown(path, uid, gid)
更改文件所有者，类似 chown，但是不追踪链接。
27 os.link(src, dst)
创建硬链接，名为参数 dst，指向参数 src
28 os.listdir(path)
返回path指定的文件夹包含的文件或文件夹的名字的列表。
29 os.lseek(fd, pos, how)
设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30 os.lstat(path)
像stat(),但是没有软链接
31 os.major(device)
从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32 os.makedev(major, minor)
以major和minor设备号组成一个原始设备号
33 os.makedirs(path[, mode])
递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34 os.minor(device)
从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35 os.mkdir(path[, mode])
以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36 os.mkfifo(path[, mode])
创建命名管道，mode 为数字，默认为 0666 (八进制)
37 os.mknod(filename[, mode=0600, device])
创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38 os.open(file, flags[, mode])
打开一个文件，并且设置需要的打开选项，mode参数是可选的
39 os.openpty()
打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40 os.pathconf(path, name)
返回相关文件的系统配置信息。
41 os.pipe()
创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42 os.popen(command[, mode[, bufsize]])
从一个 command 打开一个管道
43 os.read(fd, n)
从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44 os.readlink(path)
返回软链接所指向的文件
45 os.remove(path)
删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46 os.removedirs(path)
递归删除目录。
47 os.rename(src, dst)
重命名文件或目录，从 src 到 dst
48 os.renames(old, new)
递归地对目录进行更名，也可以对文件进行更名。
49 os.rmdir(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50 os.stat(path)
获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51 os.stat_float_times([newvalue])
决定stat_result是否以float对象显示时间戳
52 os.statvfs(path)
获取指定路径的文件系统统计信息
53 os.symlink(src, dst)
创建一个软链接
54 os.tcgetpgrp(fd)
返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55 os.tcsetpgrp(fd, pg)
设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56 os.tempnam([dir[, prefix]])
Python3 中已删除。返回唯一的路径名用于创建临时文件。
57 os.tmpfile()
Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58 os.tmpnam()
Python3 中已删除。为创建一个临时文件返回一个唯一的路径
59 os.ttyname(fd)
返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60 os.unlink(path)
删除文件路径
61 os.utime(path, times)
返回指定的path文件的访问和修改的时间。
62 os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])
输出在文件夹中的文件名通过在树中游走，向上或者向下。
63 os.write(fd, str)
写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
64 os.path 模块
获取文件的属性信息。
65 os.pardir()
获取当前目录的父目录，以字符串形式显示目录名。

18 异常

try:…except:…else:…finally…

19 类

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#类定义

class people:
#定义基本属性
name = ‘’
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def init(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print(“%s 说: 我 %d 岁。” %(self.name,self.age))
p = people(‘runoob’,10,30)
p.speak()

#类定义
class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))# 单继承示例
class student(people):grade = ''def __init__(self,n,a,w,g):#调用父类的构函people.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()

ken 说: 我 10 岁了，我在读 3 年级

#类定义
class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例
class student(people):grade = ''def __init__(self,n,a,w,g):#调用父类的构函people.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))#另一个类，多重继承之前的准备
class speaker():topic = ''name = ''def __init__(self,n,t):self.name = nself.topic = tdef speak(self):print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))#多重继承
class sample(speaker,student):a =''def __init__(self,n,a,w,g,t):student.__init__(self,n,a,w,g)speaker.__init__(self,n,t)test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法

我叫 Tim，我是一个演说家，我演讲的主题是 Python

### 方法重写。
class Parent:        # 定义父类def myMethod(self):print ('调用父类方法')class Child(Parent): # 定义子类def myMethod(self):print ('调用子类方法')c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

调用子类方法
调用父类方法

19.1 私有属性和方法。

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

20 作用域

内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。

以下实例修改全局变量 num：

num = 1
def fun1():global num  # 需要使用 global 关键字声明print(num) num = 123print(num)
fun1()
print(num)

1
123
123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

def outer():num = 10def inner():nonlocal num   # nonlocal关键字声明num = 100print(num)inner()print(num)
outer()

100
100

也可以通过函数参数传递：

a = 10
def test(a):a = a + 1print(a)
test(a)

11

21 线程

线程模块
Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

run(): 用以表示线程活动的方法。
start():启动线程活动。
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。
使用 threading 模块创建线程
我们可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法：
下面为程序示例：

import threading
import timeexitFlag = 0class myThread (threading.Thread):def __init__(self, threadID, name, delay):threading.Thread.__init__(self)self.threadID = threadIDself.name = nameself.delay = delaydef run(self):print ("开始线程：" + self.name)print_time(self.name, self.delay, 5)print ("退出线程：" + self.name)def print_time(threadName, delay, counter):while counter:if exitFlag:threadName.exit()time.sleep(delay)print ("%s: %s" % (threadName, time.ctime(time.time())))counter -= 1# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")

开始线程：Thread-1
开始线程：Thread-2
Thread-1: Sun Jun  5 17:18:27 2022
Thread-1: Sun Jun  5 17:18:28 2022Thread-2: Sun Jun  5 17:18:28 2022Thread-1: Sun Jun  5 17:18:29 2022
Thread-1: Sun Jun  5 17:18:30 2022Thread-2: Sun Jun  5 17:18:30 2022Thread-1: Sun Jun  5 17:18:31 2022
退出线程：Thread-1
Thread-2: Sun Jun  5 17:18:32 2022
Thread-2: Sun Jun  5 17:18:34 2022
Thread-2: Sun Jun  5 17:18:36 2022
退出线程：Thread-2
退出主线程

21.1 创建线程的两种方式

21.1.1 继承式

import threading # 导入库
class Thread_ (threading.Thread):def __init__(self, n):threading.Thread.__init__(self)  #重写父类方法self.num = ndef run(self):print(self.num)
if __name__ == "__main__":a = Thread_(2)  # 开启一个线程a.start()       # 启动线程

基本的线程启用，导入threading,继承 threading.Thread类，重写父类方法，必须方法为run(),在外部调用则需要则需要进行实例化，调用start()启动，而不是run()

21.1.2 面向对象式

def Test(i):print('开始测试%d'%i)time.sleep(1)print('测试结束')if __name__=='__main__':#多线程for i in range(5):#利用循环创建5个线程t=threading.Thread(target=Test,args=(i,)) # 使用线程类驱动函数，args为参数，没有可以不写，但是这样并不能够对run方法自定义，有一定的局限性#启动线程t.start()

21.2 线程同步

多线程实现同步有四种方式：
锁机制，信号量，条件判断和同步队列，这部分我主要写的是锁机制。

锁机制：如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：

多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。

考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。

那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。

锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。

经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。

21.2.1 普通锁

下面是示例（普通锁）：

import threading
import timeclass myThread (threading.Thread):def __init__(self, threadID, name, delay):threading.Thread.__init__(self)self.threadID = threadIDself.name = nameself.delay = delaydef run(self):print ("开启线程： " + self.name)# 获取锁，用于线程同步threadLock.acquire()print_time(self.name, self.delay, 3)# 释放锁，开启下一个线程threadLock.release()def print_time(threadName, delay, counter):while counter:time.sleep(delay)print ("%s: %s" % (threadName, time.ctime(time.time())))counter -= 1threadLock = threading.Lock()
threads = []# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)# 开启新线程
thread1.start()
thread2.start()# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)# 等待所有线程完成
for t in threads:t.join()
print ("退出主线程")

开启线程： Thread-1
开启线程： Thread-2
Thread-1: Sun Jun  5 17:31:21 2022
Thread-1: Sun Jun  5 17:31:22 2022
Thread-1: Sun Jun  5 17:31:23 2022
Thread-2: Sun Jun  5 17:31:25 2022
Thread-2: Sun Jun  5 17:31:27 2022
Thread-2: Sun Jun  5 17:31:29 2022
退出主线程

我们再来学习一个示例：

class myThread(threading.Thread):def __init__(self, threadID, name, counter):threading.Thread.__init__(self)self.threadID = threadIDself.name = nameself.counter = counterdef run(self):print("Start " + self.name)# 获得锁，成功获得锁定后返回True# 可选的timeout参数不填时将一直阻塞直到获得锁定# 否则超时后将返回FalsethreadLock.acquire()print_time(self.name, self.counter, 5)# 释放锁threadLock.release()
def print_time(threadName, delay, counter):while counter:time.sleep(delay)print("%s: %s" %(threadName, time.ctime(time.time())))counter -= 1threadLock = threading.Lock()
threads = []
# 创建新线程
thread1 = myThread(1, "Thread_1", 1)
thread2 = myThread(2, "Thread_2", 2)
# 开启新线程
thread1.start()
thread2.start()
# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)
# 等待所有线程完成
for t in threads:t.join()
print("Exit")

21.2.2

RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。
构造方法：mylock = Threading.RLock()

import threading
mylock = threading.RLock()
num = 0
class Thread(threading.Thread):def __init__(self, name):threading.Thread.__init__(self)self.t_name = namedef run(self):global numwhile True:mylock.acquire()print('\n%s locked, number: %d' % (self.t_name, num))if num >= 3:mylock.release()print('\n%s released, number: %d' % (self.t_name, num))breaknum += 1print('\n%s released, number: %d' % (self.t_name, num))mylock.release()
def test():thread1 = Thread('A')thread2 = Thread('B')thread1.start()thread2.start()
if __name__ == '__main__':test()

21.3 线程池

一个线程的运行时间可以分为3部分：线程的启动时间、线程体的运行时间和线程的销毁时间。在多线程处理的情景中，如果线程不能被重用，就意味着每次创建都需要经过启动、销毁和运行3个过程。这会增加系统相应的时间，降低了效率。使用线程池处理，处理当前任务之后并不销毁而是被安排处理下一个任务，能够避免多次创建线程，从而节省线程创建和销毁的开销，能带来更好的性能和系统稳定性。
方法：
futures.ThreadPoolExecutor：创建线程池
submit()：往线程池中加任务
done()：线程池中的某个线程是否完成了任务
result()：获取当前线程执行任务的结果
示例1：普通线程池

# coding:utf-8import time
import os
import threading
from concurrent.futures import ThreadPoolExecutordef work(i):print(i)time.sleep(1)if __name__ == '__main__': t = ThreadPoolExecutor(2)for i in range(10):t.submit(work, (i, ))

示例2:带有同步锁的线程池：

import time
import os
import threadingfrom concurrent.futures import ThreadPoolExecutorlock = threading.Lock()def work(i):lock.acquire()print(i)time.sleep(1)lock.release()# return 'result %s' % iif __name__ == '__main__':t = ThreadPoolExecutor(2)for i in range(10):t.submit(work, (i, ))

21.4 线程守护

有一种线程，它是在后台运行的，它的任务是为其他线程提供服务，这种线程被称为“后台线程（Daemon Thread）”，又称为“守护线程”或“精灵线程”。Python 解释器的垃圾回收线程就是典型的后台线程。如果所有的前台线程都死亡了，那么后台线程会自动死亡。

def action(max):for i in range(max):print(threading.current_thread().name + "  " + str(i))
t = threading.Thread(target=action, args=(10,), name='后台线程')
# 将此线程设置成后台线程
# 也可在创建Thread对象时通过daemon参数将其设为后台线程
t.setDaemon = True # 这一步很关键，必须在start()之前设置，否则报错
# 启动后台线程
t.start()
for i in range(10):print(threading.current_thread().name + "  " + str(i))

22 JSON

json.dumps 与 json.loads 实例

import json# Python 字典类型转换为 JSON 对象
data = {'no' : 1,'name' : 'Runoob','url' : 'http://www.runoob.com'
}json_str = json.dumps(data)
print ("Python 原始数据：", repr(data))
print ("JSON 对象：", json_str)

Python 原始数据： {'no': 1, 'name': 'Runoob', 'url': 'http://www.runoob.com'}
JSON 对象： {"no": 1, "name": "Runoob", "url": "http://www.runoob.com"}

import json# Python 字典类型转换为 JSON 对象
data1 = {'no' : 1,'name' : 'Runoob','url' : 'http://www.runoob.com'
}json_str = json.dumps(data1)
print ("Python 原始数据：", repr(data1))
print ("JSON 对象：", json_str)# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str)
print ("data2['name']: ", data2['name'])
print ("data2['url']: ", data2['url'])

Python 原始数据： {'no': 1, 'name': 'Runoob', 'url': 'http://www.runoob.com'}
JSON 对象： {"no": 1, "name": "Runoob", "url": "http://www.runoob.com"}
data2['name']:  Runoob
data2['url']:  http://www.runoob.com

# 写入 JSON 数据
with open('data.json', 'w') as f:json.dump(data, f)

# 读取数据
with open('data.json', 'r') as f:data = json.load(f)print(data)

{'no': 1, 'name': 'Runoob', 'url': 'http://www.runoob.com'}

结束语

至此，python基础的绝大部分都已经过一遍了，剩下的在学习中需要用到哪一块，再继续进行学习，以上学习内容通过菜鸟教程的实例，以及参考站内大佬的示例，并在本机上进行了实体运行，感谢上述提供借鉴的朋友。

一发入魂！15分钟让你快速入门Python相关推荐

1. 开发一番赏盲盒小程序怎么抽才能一发入魂呢

   很多人都想做属于自己的一番赏小程序,包括许多玩家在内,但是盲盒一番赏具体的瓦房是怎么样的呢 今天小编就抽时间给大家讲解一下,希望玩家朋友,平台 一发入魂!!! 一番赏盲盒的玩法: 1.全无: 赏品自由 ...

2. python选择某一行_Python常用语法有哪些 如何快速入门Python开发

   Python常用语法有哪些?如何快速入门Python开发?Python编程语言是最容易学习.并且功能强大的语言,吸引了很多人学习入行.很多人想知道如何快速入门Python开发,接下来就给大家分享Pyt ...

3. 视频教程-做游戏学Python-Python语言快速入门-Python

   做游戏学Python-Python语言快速入门 20年软件项目开发管理经验 工信部人才交流中心特聘专家讲师 日本U-CAN在线教育特聘主任讲师 国家十二·五规划软件工程教材作者(书:清华大学出版社出版 ...

4. 视频教程-快速入门Python基础教程_Python基础进阶视频-Python

   快速入门Python基础教程_Python基础进阶视频 十余年计算机技术领域从业经验,在中国电信.盛大游戏等多家五百强企业任职技术开发指导顾问,国内IT技术发展奠基人之一. 杨千锋 ¥199.00 立 ...

5. python入门教程软件-程序员带你十天快速入门Python,玩转电脑软件开发（四）

   本系列文章立志于从一个已经习得一门编程语言的基础之上,全面介绍Python的相关开发过程和相关经验总结.本篇文章主要是基于上一篇的程序员带你十天快速入门Python,玩转电脑软件开发(三)的基础之上, ...

6. python怎么样才算入门编程-新手如何快速入门Python编程？听过来人说经验！

   新手如何快速入门Python编程?站在别人的肩膀上总是要快些的,如果你不借鉴前人的经验,那么前人踩过的坑你也会踩,所以来看看吧: Python是一种编程语言,可以用来做网站.写自动化测试脚本.做数据分 ...

7. python快速编程入门黑马-新手如何快速入门Python编程?/开发python入门教程

   Python从入门到实践的教程是什么? 第一阶段Python与Linux数据这是Python的入段,也是帮助零基础学员打好基础的重要阶段,让零基础学员可以具备基础的编程能力,并掌握MySQL进阶内容. ...

8. python 计算机程序设计-某高校计算机编程教授教你如何快速入门python，一文带你进入编程...

   image 如何快速入门Python 学习任何一门语言都是从入门(1年左右),通过不间断练习达到熟练水准(3到5年),少数人最终能精通语言,成为执牛耳者,他们是金字塔的最顶层.虽然万事开头难,但好的开 ...

9. 视频教程-快速入门Python基础教程_Python基础知识大全-Python

   快速入门Python基础教程_Python基础知识大全 十余年计算机技术领域从业经验,在中国电信.盛大游戏等多家五百强企业任职技术开发指导顾问,国内IT技术发展奠基人之一. 杨千锋 ¥99.00 立即 ...

最新文章

1. 想成为牛逼程序员? 先数数编程语言之父们的头发
2. 最小二乘法，python3实现
3. QTP整合QC自动化测试--目录结构搭建
4. 经典面试题：给两个序列如何构造一棵二叉树
5. 重要的ui组件——Behavior
6. 于是按照贴吧某同学的指教，把imageViewer里那个愚蠢的语句改了
7. Git 远程配置_03
8. golang http 返回html文件_从零部署安装 Grpc-golang
9. 45.Android 第三方开源库收集整理（转）
10. LeetCode:Add Binary
11. react classname多个_React全家桶简介
12. Mybatis原理解析（三）--getMapper动态获取接口实现类
13. Qt编写输入法终极版V2018
14. 【一天一算法】冒泡排序
15. SiteSucker Pro for Mac 4.3 强大的扒站神器
16. java 三大特性_java的三大特性是什么？
17. 计算机网络系统与分布式系统之间的区别
18. linux mailx 发送多个附件,CentOS安装mailx用命令以SMTP方式发送带附件邮件可用SSL
19. 微信小程序：蓝牙通讯，搜索、发送与接收
20. 老九学堂 学习 C++ 第五天

热门文章

1. 个人Tomcat复习篇
2. certbot申请通配符域名证书
3. 如何给网站设置自定义图标（标签页显示，收藏夹显示）
4. 与人斗其乐无穷，教你回答职场送命题！
5. oracle12c 删除磁盘组,12C RAC重装无法识别磁盘组（AFD新特性）
6. 2021-08-11 TM32F103 Buffer FatFs 文件系统移植
7. 为什么有的人赚钱很简单，有的人却不行？
8. Mysql报错：SQLIntegrityConstraintViolationException: Duplicate entry ‘xxx‘ for key ‘PRIMARY‘
9. GPU服务器的上手使用-小试牛刀
10. linux 安装软件 垃圾,Ubuntu 18.04 安装垃圾清理工具 BleachBit 2.2