目录
01-作业讲解
描述--filter()
02-作业讲解
03-集合的使用
04-集合使用运算符
05-集合的练习
06-转换相关的方法
Python3 JSON 数据解析
07-公共方法
09-函数的参数
10-函数的返回值
11-函数的注释
12-函数调用函数
13-全局变量和局部变量
14-函数多个返回值
01-作业讲解
students = [
{'name': '张三', 'age': 18, 'score': 52, 'tel': '1388888998', 'gender': 'female'},
{'name': '李四', 'age': 28, 'score': 89, 'tel': '1388666666', 'gender': 'male'},
{'name': '王五', 'age': 21, 'score': 95, 'tel': '1365588889', 'gender': 'unknown'},
{'name': 'jerry', 'age': 20, 'score': 90, 'tel': '156666789', 'gender': 'unknown'},
{'name': 'chris', 'age': 17, 'score': 98, 'tel': '13777775523', 'gender': 'male'},
{'name': 'jack', 'age': 23, 'score': 52, 'tel': '13999999928', 'gender': 'female'},
{'name': 'tony', 'age': 15, 'score': 98, 'tel': '1388888888', 'gender': 'unknown'}
]
# (1) 统计不及格学生的个数
# (2) 打印不及格学生的名字和对应的成绩
# (3) 统计未成年学生的个数
# (4) 打印手机尾号是8的学生的名字
# (5) 打印最高分和对应的学生的名字
count = 0
teenager_count = 0
max_score = students[0]['score'] # 假设第0个学生的成绩是最高分
# max_index = 0 # 假设最高分的学生下标是 0
for i, student in enumerate(students):
if student['score'] < 60:
count += 1
print('%s不及格,分数是%d' % (student['name'], student['score']))
if student['age'] < 18:
teenager_count += 1
# if student['tel'].endswith('8'):
if student['tel'][-1] == '8':
print('%s的手机号以8结尾' % student['name'])
if student['score'] > max_score: # 遍历时,发现了一个学生的成绩大于假设的最大数
max_score = student['score']
# max_index = i # 修改最高分的同时,把最高分的下标也修改
print('不及格的学生有%d个' % count)
print('未成年的学生有%d个' % teenager_count)
print('最高成绩是%d' % max_score)
for student in students:
if student['score'] == max_score:
print('最高分是%s' % student['name'])
# print('最高分名字是%s' % students[max_index]['name'])
# (6) 删除性别不明的所有学生(这个地方有个坑,跳不出来的话大家可以在群里套路,或者等老师的解答)
# 方法一,将不需要删除的数据添加到新列表
new_students = [x for x in students if x['gender'] != 'unknown']
print(new_students)
# 方法二,使用for循环倒着删除要删除的数据,避免“坑”
i = 0
for i in range(len(students) - 1, -1, -1):
if students[i]['gender'] == 'unknown':
students.remove(students[i])
print(students)
# 方法三,使用while循环删除需要删除的数据,并及时补齐因删除数据而导致的列表数据索引变化,避免漏删数据
i = 0
while i < len(students):
if students[i]['gender'] == 'unknown':
students.remove(students[i])
i -= 1
i += 1
print(students)
# 方法四,遍历在新的列表操作,删除是在原来的列表操作(students[:]是studens的切片,所以修改students对切片无影响)
i = 0
for student in students[:]:
if student['gender'] == 'unknown':
students.remove(student)
print(students)
# 方法五,使用内建函数filter()和匿名函数
new_students = filter(lambda x: x['gender'] != 'unknown', students)
print(list(new_students))
print('-------------------------------')
# (7) 将列表按学生成绩从大到小排序(选做)
for j in range(0, len(students) - 1):
for i in range(0, len(students) - 1 - j):
if students[i]['score'] < students[i + 1]['score']:
students[i], students[i + 1] = students[i + 1], students[i]
print(students)
描述--filter()
filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象,如果要转换为列表,可以使用 list() 来转换。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
语法
以下是 filter() 方法的语法:
filter(function, iterable)
参数
- function -- 判断函数。
- iterable -- 可迭代对象。
返回值
返回一个迭代器对象
实例:
过滤出列表中的所有奇数: #!/usr/bin/python3 def is_odd(n): return n % 2 == 1 tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) newlist = list(tmplist) print(newlist)过滤出1~100中平方根是整数的数: #!/usr/bin/python3 import math def is_sqr(x): return math.sqrt(x) % 1 == 0 tmplist = filter(is_sqr, range(1, 101)) newlist = list(tmplist) print(newlist) 输出结果 : [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Python3 函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
- 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号 : 起始,并且缩进。
- return [表达式] 结束函数,选择性地返回一个值给调用方,不带表达式的 return 相当于返回 None。
语法
Python 定义函数使用 def 关键字,一般格式如下:
def 函数名(参数列表): 函数体
默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
计算面积函数: #!/usr/bin/python3 # 计算面积函数 def area(width, height): return width * height def print_welcome(name): print("Welcome", name) print_welcome("Runoob") w = 4 h = 5 print("width =", w, " height =", h, " area =", area(w, h)) 以上实例输出结果: Welcome Runoob width = 4 height = 5 area = 20
函数调用
定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构。 这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从 Python 命令提示符执行。 如下实例调用了 printme() 函数: 实例(Python 3.0+) #!/usr/bin/python3 # 定义函数 def printme( str ): # 打印任何传入的字符串 print (str) return # 调用函数 printme("我要调用用户自定义函数!") printme("再次调用同一函数") 以上实例输出结果: 我要调用用户自定义函数! 再次调用同一函数
参数传递
在 python 中,类型属于对象,对象有不同类型的区分,变量是没有类型的:
a=[1,2,3] a="Runoob"
以上代码中,[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
- 不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变 a 的值,相当于新生成了 a。
- 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
python 函数的参数传递:
- 不可变类型:类似 C++ 的值传递,如整数、字符串、元组。如 fun(a),传递的只是 a 的值,没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值,则是新生成一个 a 的对象。
- 可变类型:类似 C++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后 fun 外部的 la 也会受影响
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
python 传不可变对象实例
通过 id() 函数来查看内存地址变化:
通过 id() 函数来查看内存地址变化: 实例(Python 3.0+) def change(a): print(id(a)) # 指向的是同一个对象 a=10 print(id(a)) # 一个新对象 a=1 print(id(a)) change(a) 以上实例输出结果为: 4379369136 4379369136 4379369424 可以看见在调用函数前后,形参和实参指向的是同一个对象(对象 id 相同),在函数内部修改形参后,形参指向的是不同的 id。传可变对象实例 可变对象在函数里修改了参数,那么在调用这个函数的函数里,原始的参数也被改变了。例如: 实例(Python 3.0+) #!/usr/bin/python3 # 可写函数说明 def changeme( mylist ): "修改传入的列表" mylist.append([1,2,3,4]) print ("函数内取值: ", mylist) return # 调用changeme函数 mylist = [10,20,30] changeme( mylist ) print ("函数外取值: ", mylist) 传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下: 函数内取值: [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]]
参数
以下是调用函数时可使用的正式参数类型:
- 必需参数
- 关键字参数
- 默认参数
- 不定长参数
必需参数 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。 调用 printme() 函数,你必须传入一个参数,不然会出现语法错误: 实例(Python 3.0+) #!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str) return # 调用 printme 函数,不加参数会报错 printme() 以上实例输出结果: Traceback (most recent call last): File "test.py", line 10, in <module> printme() TypeError: printme() missing 1 required positional argument: 'str' 关键字参数 关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。 使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。 以下实例在函数 printme() 调用时使用参数名: 实例(Python 3.0+) #!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str) return #调用printme函数 printme( str = "菜鸟教程") 以上实例输出结果: 菜鸟教程 以下实例中演示了函数参数的使用不需要使用指定顺序: 实例(Python 3.0+) #!/usr/bin/python3 #可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数 printinfo( age=50, name="runoob" ) 以上实例输出结果: 名字: runoob 年龄: 50 默认参数 调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入 age 参数,则使用默认值: 实例(Python 3.0+) #!/usr/bin/python3 #可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数 printinfo( age=50, name="runoob" ) print ("------------------------") printinfo( name="runoob" ) 以上实例输出结果: 名字: runoob 年龄: 50 ------------------------ 名字: runoob 年龄: 35 不定长参数 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。基本语法如下: def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression] 加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。 实例(Python 3.0+) #!/usr/bin/python3 # 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vartuple) # 调用printinfo 函数 printinfo( 70, 60, 50 ) 以上实例输出结果: 输出: 70 (60, 50) 如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例: 实例(Python 3.0+) #!/usr/bin/python3 # 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) for var in vartuple: print (var) return # 调用printinfo 函数 printinfo( 10 ) printinfo( 70, 60, 50 ) 以上实例输出结果: 输出: 10 输出: 70 60 50 还有一种就是参数带两个星号 **基本语法如下: def functionname([formal_args,] **var_args_dict ): "函数_文档字符串" function_suite return [expression] 加了两个星号 ** 的参数会以字典的形式导入。 实例(Python 3.0+) #!/usr/bin/python3 # 可写函数说明 def printinfo( arg1, **vardict ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vardict) # 调用printinfo 函数 printinfo(1, a=2,b=3) 以上实例输出结果: 输出: 1 {'a': 2, 'b': 3} 声明函数时,参数中星号 * 可以单独出现,例如: def f(a,b,*,c): return a+b+c 如果单独出现星号 * 后的参数必须用关键字传入。 >>> def f(a,b,*,c): ... return a+b+c ... >>> f(1,2,3) # 报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: f() takes 2 positional arguments but 3 were given >>> f(1,2,c=3) # 正常 6 >>>
匿名函数
Python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
- lambda 只是一个表达式,函数体比 def 简单很多。
- lambda 的主体是一个表达式,而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
- 虽然 lambda 函数看起来只能写一行,却不等同于 C 或 C++ 的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda 函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
设置参数 a 加上 10: 实例 x = lambda a : a + 10 print(x(5)) 以上实例输出结果: 15以下实例匿名函数设置两个参数: 实例(Python 3.0+) #!/usr/bin/python3 # 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数 print ("相加后的值为 : ", sum( 10, 20 )) print ("相加后的值为 : ", sum( 20, 20 )) 以上实例输出结果: 相加后的值为 : 30 相加后的值为 : 40 我们可以将匿名函数封装在一个函数内,这样可以使用同样的代码来创建多个匿名函数。 以下实例将匿名函数封装在 myfunc 函数中,通过传入不同的参数来创建不同的匿名函数: 实例 def myfunc(n): return lambda a : a * n mydoubler = myfunc(2) mytripler = myfunc(3) print(mydoubler(11)) print(mytripler(11)) 以上实例输出结果: 22 33
return语句
return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值,以下实例演示了 return 语句的用法:
实例(Python 3.0+) #!/usr/bin/python3 # 可写函数说明 def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print ("函数内 : ", total) return total # 调用sum函数 total = sum( 10, 20 ) print ("函数外 : ", total) 以上实例输出结果: 函数内 : 30 函数外 : 30
补:
强制位置参数 Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数,不能使用关键字参数的形式。 在以下的例子中,形参 a 和 b 必须使用指定位置参数,c 或 d 可以是位置形参或关键字形参,而 e 和 f 要求为关键字形参: def f(a, b, /, c, d, *, e, f): print(a, b, c, d, e, f) 以下使用方法是正确的: f(10, 20, 30, d=40, e=50, f=60) 以下使用方法会发生错误: f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式 f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式
02-作业讲解
# 用三个元组表示三门学科的选课学生姓名(一个学生可以同时选多门课)
sing = ('李白', '白居易', '李清照', '杜甫', '王昌龄', '王维', '孟浩然', '王安石')
dance = ('李商隐', '杜甫', '李白', '白居易', '岑参', '王昌龄')
rap = ('李清照', '刘禹锡', '岑参', '王昌龄', '苏轼', '王维', '李白')
# (1) 求选课学生总共有多少人
# 元组之间支持加法运算
# 使用集合set可以去重
total = set(sing + dance + rap)
print(len(total))
# (2) 求只选了第一个学科的人的数量和对应的名字
sing_only = []
for p in sing:
if p not in dance and p not in rap:
sing_only.append(p)
print('只选择了第一个学科的有{}人,是{}'.format(len(sing_only), sing_only))
# (3) 求只选了一门学科的学生的数量和对应的名字
# (4) 求只选了两门学科的学生的数量和对应的名字
# (5) 求只选了三门学生的学生的数量和对应的名字
p_dict = {} # 空字典
all_persons = sing + dance + rap
print(all_persons)
# ('李白', '白居易', '李清照', '杜甫', '王昌龄', '王维', '孟浩然', '王安石', '李商隐', '杜甫', '李白', '白居易', '岑参', '王昌龄', '李清照', '刘禹锡', '岑参', '王昌龄', '苏轼', '王维', '李白')
for name in all_persons:
if name not in p_dict:
p_dict[name] = all_persons.count(name)
print(p_dict)
for k, v in p_dict.items():
if v == 1:
print('报了一门的有', k)
elif v == 2:
print('报了两门的有', k)
elif v == 3:
print('报了三门的有', k)
03-集合的使用
# 集合是一个不重复的无序,可以使用 {} 或者 set 来表示
# {} 有两种意思: 字典、集合
# {} 里如果放的是键值对,它就是一个字典;如果 {} 放的是单个的值,就是一个集合
person = {'name': 'zhangsan', 'age': 18} # 字典
x = {'hello', 1, 'good'} # 集合
# 如果有重复的数据,会自动去除
names = {'zhangsan', 'lisi', 'jack', 'tony', 'jack', 'lisi'}
print(names)
# set能不能进行增删改查
names.add('阿珂') # 添加一个元素
print(names)
names.pop() # 删除一个
print(names)
names.remove('jack') # 删除一个指定的元素
print(names)
# union 将多个集合合并生成一个新的集合
# A.update(B) 将B拼接到A里
names.update(['刘能', '赵四'])
print(names)
# names.clear() # 清空一个集合
# 空集合的表示方式不是 {} , {} 表示的是空字典
# 空集合 set()
# print(names)
print('jack' in names)
# 集合是一个不重复的无序,可以使用 {} 或者 set 来表示 # {} 有两种意思: 字典、集合 # {} 里如果放的是键值对,它就是一个字典;如果 {} 放的是单个的值,就是一个集合
# 如果有重复的数据,会自动去除 names = {'zhangsan', 'lisi', 'jack', 'tony', 'jack', 'lisi'} print(names) # set能不能进行增删改查 names.add('阿珂') # 添加一个元素 print(names) names.pop() # 删除一个 print(names) names.remove('jack') # 删除一个指定的元素 print(names) # union 将多个集合合并生成一个新的集合 # A.update(B) 将B拼接到A里 names.update(['刘能', '赵四']) print(names) # names.clear() # 清空一个集合 # 空集合的表示方式不是 {} , {} 表示的是空字典 # 空集合 set()
04-集合使用运算符
first = {'李白', '白居易', '李清照', '杜甫', '王昌龄', '王维', '孟浩然', '王安石'}
second = {'李商隐', '杜甫', '李白', '白居易', '岑参', '王昌龄'}
# set 支持很多算数运算符
# print(first + second) 这个是错的
print(first - second) # A - B 求A和B的 差集
print(second - first)
print(first & second) # A & B 求A和B的 交集
print(first | second) # A | B 求A和B的 并集
print(first ^ second) # A ^ B 求A和B差集的并集
# set 支持很多算数运算符
print(second - first)# A - B 求A和B的 差集
print(first & second) # A & B 求A和B的 交集
print(first | second) # A | B 求A和B的 并集
print(first ^ second) # A ^ B 求A和B差集的并集
05-集合的练习
# 去重排序
nums = [5, 8, 7, 6, 4, 1, 3, 5, 1, 8, 4]
x = set(nums)#set去重
y = list(x)#list定义成列表
y.sort(reverse=True)#排序,反转成降序
print(y) #打印
06-转换相关的方法
# 内置类 list tuple set
nums = [9, 8, 4, 3, 2, 1]
x = tuple(nums) # 使用tuple内置类转换成为元组
print(x)
y = set(nums) # 使用set内置类转换成为集合
print(y)
z = list({'name': 'zhangsan', 'age': 18, 'score': 98})
print(z)
# Python里有一个比较强大的内置函数eval,可以执行字符串里的代码
a = 'input("请输入您的用户名")' # a是一个字符串
b = '1+1'
print(eval(b))
import json
# JSON的使用,把列表、元组、字典等转换成为JSON字符串
person = {'name': 'zhangsan', 'age': 18, 'gender': 'female'}
# 字典如果想要把它传给前端页面或者把字典写入到一个文件里
m = json.dumps(person) # dumps将字典、列表、集合、元组等转换成为JSON字符串
print(m) # '{"name": "zhangsan", "age": 18, "gender": "female"}'
# print(type(m)) # <class 'str'>
# print(m['name']) 不能这样使用,m是一个字符串,不能再像字典一样根据key获取value
# Python JSON
# True true
# False false
# 字符串 字符串
# 字典 对象
# 列表、元组 数组
print(json.dumps(['hello', 'good', 'yes', True]))
print(json.dumps(('hello', 'good', 'yes', False)))
# # n = '{"name": "lisi", "age": 20, "gender": "male"}'
n = '["hello","good"]'
# # p = eval(n)
# # print(type(p))
s = json.loads(n) # loads可以将json字符串转换成为Python里的数据
print(s)
# print(type(s))
内置函数eval,
# Python里有一个比较强大的内置函数eval,可以执行字符串里的代码
a = 'input("请输入您的用户名")' # a是一个字符串
b = '1+1'
print(eval(b))
Python3 JSON 数据解析
JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。
如果你还不了解 JSON,可以先阅读我们的 JSON 教程。
Python3 中可以使用 json 模块来对 JSON 数据进行编解码,它包含了两个函数:
- json.dumps(): 对数据进行编码。
- json.loads(): 对数据进行解码。
在 json 的编解码过程中,Python 的原始类型与 json 类型会相互转换,具体的转化对照如下:
Python 编码为 JSON 类型转换对应表:
PythonJSONdictobjectlist, tuplearraystrstringint, float, int- & float-derived EnumsnumberTruetrueFalsefalseNonenull
JSON 解码为 Python 类型转换对应表:
JSONPythonobjectdictarrayliststringstrnumber (int)intnumber (real)floattrueTruefalseFalsenullNone
json.dumps 与 json.loads 实例
son.dumps 与 json.loads 实例 以下实例演示了 Python 数据结构转换为JSON: 实例(Python 3.0+) #!/usr/bin/python3 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 原始数据: {'url': 'http://www.runoob.com', 'no': 1, 'name': 'Runoob'} JSON 对象: {"url": "http://www.runoob.com", "no": 1, "name": "Runoob"} 通过输出的结果可以看出,简单类型通过编码后跟其原始的repr()输出结果非常相似。 接着以上实例,我们可以将一个JSON编码的字符串转换回一个Python数据结构: 实例(Python 3.0+) #!/usr/bin/python3 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 原始数据: {'name': 'Runoob', 'no': 1, 'url': 'http://www.runoob.com'} JSON 对象: {"name": "Runoob", "no": 1, "url": "http://www.runoob.com"} data2['name']: Runoob data2['url']: http://www.runoob.com 如果你要处理的是文件而不是字符串,你可以使用 json.dump() 和 json.load() 来编码和解码JSON数据。例如: 实例(Python 3.0+) # 写入 JSON 数据 with open('data.json', 'w') as f: json.dump(data, f) # 读取数据 with open('data.json', 'r') as f: data = json.load(f) 更多资料请参考:https://docs.python.org/3/library/json.html
这里简单理解:
m = json.dumps(n) # dumps将字典、列表、集合、元组等转换成为JSON字符串
s = json.loads(n) # loads可以将json字符串转换成为Python里的数据
repr() 函数描述
repr() 函数将对象转化为供解释器读取的形式。
语法
以下是 repr() 方法的语法:
repr(object)
参数
- object -- 对象。
返回值
返回一个对象的 string 格式。
07-公共方法
# + :可以用来拼接,用于 字符串、元组、列表
print('hello' + 'world')
print(('good', 'yes') + ('hi', 'ok'))
print([1, 2, 3] + [4, 5, 6])
# -:只能用户集合,求差集
print({1, 2, 3} - {3})
# *:可以用于字符串元组列表,表示重复多次。不能用于字典和集合
print('hello' * 3)
print([1, 2, 3] * 3)
print((1, 2, 3) * 3)
# in:成员运算符
print('a' in 'abc')
print(1 in [1, 2, 3])
print(4 in (6, 4, 5))
# in 用于字典是用来判断key是否存在
print('zhangsan' in {'name': 'zhangsan', 'age': 18, 'height': '180cm'})
print('name' in {'name': 'zhangsan', 'age': 18, 'height': '180cm'})
print(3 in {3, 4, 5})
# nums = [19, 82, 39, 12, 34, 58]
nums = (19, 82, 39, 12, 34, 58)
# nums = {19, 82, 39, 12, 34, 58}
# 带下标的遍历 enumerate 类的使用,一般用户列表和元组等有序的数据
for i, e in enumerate(nums):
print('第%d个数据是%d' % (i, e))
person = {'name': 'zhangsan', 'age': 18, 'height': '180cm'}
for i, k in enumerate(person):
print(i, k)
# + :可以用来拼接,用于 字符串、元组、列表
# -:只能用户集合,求差集
print({1, 2, 3} - {3})
# *:可以用于字符串元组列表,表示重复多次。不能用于字典和集合
# in:成员运算符
# in 用于字典是用来判断key是否存在
# nums = {19, 82, 39, 12, 34, 58}
# 带下标的遍历 enumerate 类的使用,一般用户列表和元组等有序的数据
for i, e in enumerate(nums):
print('第%d个数据是%d' % (i, e))
person = {'name': 'zhangsan', 'age': 18, 'height': '180cm'}
for i, k in enumerate(person):
print(i, k)
08-函数的介绍
# 函数就是一堆准备好的代码,在需要的时候调用这一堆代码
# 缺点:冗余、可读性很差、维护性太差
# 把多行代码封装成一个整体(函数)
# 在Python里,使用关键字 def 来声明一个函数
# def 函数名(参数):
# 函数要执行的操作
# 函数定义好了以后并不会自动执行
def tell_story():
print('从前有座山')
print('山上有座庙')
print('庙里有个老和尚')
print('还有一个小和尚')
print('老和尚在给小和尚讲故事')
print('故事的内容是')
age = int(input('请输入孩子的年龄:'))
if 0 <= age < 3:
for i in range(5):
tell_story() # 函数名(参数)
elif 5 > age >= 3:
tell_story()
# 函数就是一堆准备好的代码,在需要的时候调用这一堆代码
# 缺点:冗余、可读性很差、维护性太差
# 把多行代码封装成一个整体(函数)
# 在Python里,使用关键字 def 来声明一个函数
# def 函数名(参数):
# 函数要执行的操作
09-函数的参数
# def 函数名(参数):
# 函数体
# 调用函数: 函数名(参数)
# 函数声明时,括号里的参数我们称之为形式参数,简称形参
# 形参的值是不确定的,只是用来占位的
def tell_story(person1, person2):
print('从前有座山')
print('山上有座庙')
print('庙里有个' + person1)
print('还有一个' + person2)
print(person1 + '在给' + person2 + '讲故事')
# 调用函数时传递数据
# 函数调用时传入的参数,才是真正参与运算的数据,我们称之为实参
tell_story('老道', '道童') # 会把实参一一对应的传递,交给形参处理
tell_story('师太', '小尼姑')
# 还可以通过定义变量名的形式给形参赋值
tell_story(person2='青年', person1='禅师')
# def 函数名(参数): #这个参数叫形参
# 函数体
# 调用函数: 函数名(参数) #这里的这个参数叫实参
# 函数声明时,括号里的参数我们称之为形式参数,简称形参
# 形参的值是不确定的,只是用来占位的
# 调用函数时传递数据
# 函数调用时传入的参数,才是真正参与运算的数据,我们称之为实参
tell_story('老道', '道童') # 会把实参一一对应的传递,交给形参处理
10-函数的返回值
# 返回值就是函数执行的结果,并不是所有的函数都必须要有返回值
def add(a, b):
c = a + b # 变量c在外部是不可见的,只能在函数内部使用
return c # return 表示一个函数的执行结果
# 获取到 add 函数的结果,然后再求结果的 4 次方
result = add(1, 2)
print(result ** 4)
# 如果一个函数没有返回值,它的返回就是None
# print就是一个内置函数
x = print('hello')
print(x) # None
age = input('请输入您的年龄:')
print(age)
11-函数的注释
def add(a: int, b: int):
"""
这个函数用来将两个数字相加
:param a: 第一个数字
:param b: 第二个数字
:return: 两个数字相加的结果
"""
return a + b
x = add(1, 2)
print(x)
y = add('hello', 'world')
print(y)
# z = add('hello', 5)
# print(z)
# help(add)
12-函数调用函数
def test1():
print('test1开始了')
print('test1结束了')
def test2():
print('test2开始了')
test1()
print('test2结束了')
test2()
# 定义函数求[n,m)之间所有整数之和
def add(n, m):
x = 0
for i in range(n, m):
x += i
return x
result = add(0, 101)
# 求一个n的阶乘
def factorial(n):
x = 1
for i in range(1, n + 1):
x *= i
return x
# 计算m阶乘的和 m=6 ==> 1!+2!+3!+4!+5!+6!
def fac_sum(m):
x = 0
for i in range(1, m + 1):
x += factorial(i)
return x
z = fac_sum(5)
print(z)
13-全局变量和局部变量
a = 100 # 这个变量是全局变量,在整个py文件里都可以访问
word = '你好'
def test():
x = 'hello' # 这个变量是在函数内部定义的变量,它是局部变量,只能在函数内部使用
print('x = {}'.format(x))
# 如果局部变量的名和全局变量同名,会在函数内部又定义一个新的局部变量
# 而不是修改全局变量
a = 10
print('函数内部a = {}'.format(a))
# 函数内部如果想要修改全局变量?
# 使用global对变量进行声明,可以通过函数修改全局变量的值
global word
word = 'ok'
print('locals = {},globals = {}'.format(locals(), globals()))
test()
# print(x) # x只能在函数内部使用
print('函数外部a = {}'.format(a))
print('函数外部word={}'.format(word))
# 内置函数 globals()可以查看全局变量 locals()可以查看局部变量
# 在Python里,只有函数能够分割作用域
if 3 > 2:
m = 'hi'
print(m)
print(globals())
a = 100 # 这个变量是全局变量,在整个py文件里都可以访问
x = 'hello' # 这个变量是在函数内部定义的变量,它是局部变量,只能在函数内部使用
14-函数多个返回值
def test(a, b):
x = a // b
y = a % b
# 一般情况下,一个函数最多只会执行一个return语句
# 特殊情况(finally语句)下,一个函数可能会执行多个return语句
# return x # return语句表示一个函数的结束
# return {'x': x, 'y': y}
# return [x, y]
# return (x, y)
return x, y # 返回的本质是一个元组
result = test(13, 5)
print('商是{},余数是{}'.format(result[0], result[1]))
shang, yushu = test(8, 3)
print('商是{},余数是{}'.format(shang, yushu))
# print('商是{},余数是{}'.format(result['x'], result['y']))
print('商是{},余数是{}'.format(result[0], result[1]))