python-08-函数基础

老板来片烤面包

已于 2022-04-06 19:23:42 修改

阅读量841

点赞数 1

分类专栏： python全栈技术文章标签： python

于 2022-04-03 11:37:24 首次发布

本文链接：https://blog.csdn.net/gregcsdn/article/details/123925086

版权

python全栈技术专栏收录该内容

22 篇文章 4 订阅

订阅专栏

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 类型转换对应表：

Python JSON
dict object
list, tuple array
str string
int, float, int- & float-derived Enums number
True true
False false
None null

JSON 解码为 Python 类型转换对应表：

JSON Python
object dict
array list
string str
number (int) int
number (real) float
true True
false False
null None

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 格式。

Python	JSON
dict	object
list, tuple	array
str	string
int, float, int- & float-derived Enums	number
True	true
False	false
None	null

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

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']))