Python入门分享（三）

代码编写

json

json并不是一种数据类型

在Python语言当中，json可以看做是一种特殊的字符串，这种字符串特殊在于它的写法——它是用列表/字典的语法写成的。

不是所有的编程语言都能读懂Python里的数据类型（如，列表/字典），但是所有的编程语言，都支持文本，也就是json，所以可以把json看做为一个桥梁，用于“服务端”与“前端”或者“服务端”与“服务端”的交互。

// json可以写成以下形式
c = '[1,2,3,4]'

json与str和Dict之间的转换

通过json可以将str与Dict进行转换

import json
// str ===> json  使用dumps
json_data = "{'name': 'xiaowang','age': 18,'address': 'beijing'}"
print(type(json_data))
jd = json.dumps(json_data)
print(type(jd))
print(jd)

// json ==> dict
dic = {'name': 'xiaowang', 'age': 18, 'address': 'beijing'}

print(dic)
print(type(dic))
//将Dict通过json转换成str
dic_json = json.dumps(dic)
print(dic_json)
print(type(dic_json))

//将str通过loads转dict"
str_json = '{"name": "xiaowang", "age": 18, "address": "beijing"}'
str_dic = json.loads(str_json)
print(str_dic)
print(type(str_dic))

函数

函数就是可以重复使用的、用来实现单一功能的代码
用法：函数名(参数名)，括号内容可以为空，也可以为一个或者多个参数

//	使用def定义函数	def 函数名(参数名)
def func(x, y):	//这里的x和y为形参
//	函数体
    print(x + y)
//	函数调用		函数名(参数)
func(1, 2)			//这里的1, 2为实参
func("a", "b")		//这里的"a", "b"为实参
//	如果函数中遇到pass，则暂时跳过方法内容的校验
def func_pass():
    pass

如果定义函数时，括号里面有值，则这个值就是形参

传参

默认传参和关键字传参

//	默认值传参
def function_params(x, y=1, z=2):
    print(x + y + z)
//	关键字传参 
function_params(x=1, z=2)

注意：如果在默认传参的基础上使用关键字传参，则默认传参的参数需要放在最后

//	错误写法
def function_params1(x, y=1, z):
    print(x + y + z)
function_params1(x=1, z=2)
/*报错
def function_params1(x, y=1, z):
                        ^
SyntaxError: non-default argument follows default argument*/
//正确写法
def function_params1(x, z, y=1):
    print(x + y + z)
function_params1(x=1, z=2)

可变参——参数的数量是可变的

/*	可变参传递的参数，以一个元祖的形式去收集，并且给到程序内部使用
定义可变参	def 函数名(*参数名)
*/
def function_params2(*args):
    for i in args:
        print(i)
function_params2("1", "2", "3")
function_params2(1, 2, 3)
function_params2(["1", "2", "3"], ["1", "2", "3"], ["1", "2", "3"], ["1", "2", "3"])
/*可变关键字传参, kwargs 约定俗成的名字，  ** 是真正影响按照关键字传参并转为dict的原因
def 函数名(**kwargs)*/
//错误写法
def function_params3(**kwargs):
    print(kwargs)
    print(type(kwargs))
function_params3("xiaobai", 10)
/*报错
function_params3("xiaobai", 10)
TypeError: function_params3() takes 0 positional arguments but 2 were given
*/
//正确写法
def function_params3(**kwargs):
    print(kwargs)
    print(type(kwargs))
function_params3(name="xiaobai", age=10)

返回值与return的使用

返回单个值

函数内部遇到return语句，就会停止执行并返回结果。没有return语句的函数， Python也会在末尾隐性地加上return None，即返回None值（return None可以简写为 return。）

//	使用方法
def function_return():
    return 1 + 1
v = function_return()
print(v)	//输出：2
// def fun1():
	return 1, 2, 3	//输出：(1, 2, 3)
//*例：写出一个可以计算字符串长度的函数
def my_len(words):
    counter = 0
    for i in words:
        counter = counter + 1
    return counter

a = '八百标兵奔北坡，炮兵并排北边跑'
print(my_len(a))

返回多个值

//	正确使用方法	
def function_return_many():
    return 1, 2, 3
a, b, c = function_return_many()
print(a, b, c)
//错误实例
def function_return_many():
    return 1, 2, 3
q, e = function_return_many()
/*报错
q, e = function_return_many()
ValueError: too many values to unpack (expected 2)
*/

作用域

程序中的变量并不是在哪个位置都可以被使用的，使用权限决定于这个变量是在哪里赋值的。因此衍生出来两个概念：局部变量和全局变量
局部变量：一个在函数内部赋值的变量仅能在该函数内部使用（局部作用域）。
在所有函数之外赋值的变量，可以在程序的任何位置使用（全局作用域）。

//	全局变量
fa = 2
def function_area():
// 局部变量 
    fa = 1
print(fa)	//输出：2

//如何在内部影响到全局 需要使用global语句
def function_area1():
    global fb
    fb = 3
function_area1()	//方法一定得被调用才能生效
print(fb)	//输出：3    

函数嵌套

函数嵌套即在一个函数内部调用其他函数。

/*	例：假设要算出这个月的利润增长率，公式为：本月利润增长额 / 上月利润 * 100%，因为除数不能为0，所以当除数为零时候输出：当除数为0的时候重新输入数值
*/
//	定义函数div 来计算增长率
def div(num1, num2):
    growth = (num1 - num2) / num2
    //将计算出的增长率转换为str
    percent = str(growth * 100) + '%'
    return percent
//	定义函数warning 作为错误场景时候触发该函数
def warning():
    print('Error: 你确定上个月一毛钱都不赚不亏吗？')
//	主函数
def main():
    while True:
        num1 = float(input('请输入本月所获利润'))
        num2 = float(input('请输入上月所获利润'))
        if num2 == 0:
            warning()
        else:
            print('本月的利润增长率：' + div(num1,num2))
            break
main()
//调用的一定是一个在全局中声明过的函数，如果是在局部声明的，在全局中是无法被调用

递归

递归：函数的内部调用自己，多用于循环或者多层嵌套的场景，但这样做容易出现问题：死循环
注意：1、每个递归程序之中，一定要有一个结束逻辑
2、跳出的时候需要用return，不能用break， break是循环中使用的，而return是方法中返回结果，返回结果代表了方法结束
3、非必要不写递归

def function_clac1(num):
    print(num)
    if int(num / 2) == 0:
        return
    function_clac1(int(num / 2))
function_clac1(10)
/*  输出结果为
10
5
2
1
*/
//	不用递归的时候 代码如下
def function_clac2(num):
    print(num)
    return int(num / 2)
flag = True
nums = 10
while flag:
    nums = function_clac2(nums)
    if nums == 0:
        flag = False

多维数组嵌套

使用extend()

extend() 函数用于在列表末尾一次性追加另多个序列中的多个值（用新列表扩展原来的列表）如果extend的是字符串，则字符串会被拆分成字符数组，如果extend的是字典，则字典的key会被加入到ist中。

list1 = [1, 2]
list2 = [2, 4, 5]
list3 = []
list2.append(list1)
print("list2::", list2)
// 输出：list2:: [2,4,5,[1,2]] list1的元素作为一个列表整体被加入list2
list3.extend(list1)
print("list3::", list3)
// 输出[1,2] list1的元素独立加入list3中

其中的list2在加入list1的元素后，list2变成了一个二维数组

多维数组实例

// wsc现有资产
wsc = {
    "money": 19000,
    "house": {
        "beijing": ["三环", "四环", "五环"],
        "shanghai": ["静安区", "浦东新区"]
    },
    "car": ["bmw", 'benz', 'audi', 'byd'],
    "pets": [
        {"name": "xiaohei", "type": "dog"},
        {"name": "xiaobai", "type": "cat"},
        {"name": "xiaofen", "type": "cat"},
        {"name": "xiaolan", "type": "dog"},
    ]
}

/*在这个月 wsc的资产发生了以下变化：
1、买了一辆五菱宏光
2、在杭州西湖区买了房子
3、卖掉北京5环的房子，钱增加了 500w
4、收养了一只叫咪咪的猫*/

//统计一下他总共有几辆车
wsc["car"].append("五菱宏光")
wsc["house"]["hangzhou"] = ["西湖区"]
wsc["house"]["beijing"].remove("五环")
wsc["money"] += 5000000
wsc["pets"].insert(0, {"name": "咪咪", "type": "cat"})
print("用有车的数量：",len(wsc["car"]))
print(wsc)
/* 输出：
用有车的数量： 5
{'money': 5019000, 'house': {'beijing': ['三环', '四环'], 'shanghai': ['静安区', '浦东新区'], 'hangzhou': ['西湖区']}, 'car': ['bmw', 'benz', 'audi', 'byd', '五菱宏光'], 'pets': [{'name': '咪咪', 'type': 'cat'}, {'name': 'xiaohei', 'type': 'dog'}, {'name': 'xiaobai', 'type': 'cat'}, {'name': 'xiaofen', 'type': 'cat'}, {'name': 'xiaolan', 'type': 'dog'}]}
*/

内置函数集锦

函数	含义
len	返回对象（字符、列表、元组等）长度或项目个数
str	将对象转化为适于string的形式
list	用于将元组转换为列表
int	一个字符串或数字转换为整型
set	创建一个无序不重复元素集
print	用于打印输出
input	用来接受一个控制台输入的数据
id	获取内存地址
type	获取数据类型
open	打开文件
sorted	排序
abs	返回一个数的绝对值
max	返回给定参数的最大值
min	返回给定参数的最小值
sum	对序列进行求和计算
ord	打印字符串对应的ASCII码
dir	打印传入对象的可调用方法
bool	把一个对象转换成布尔类型
locals	返回当前的局部变量,放在一个字典里面
reversed	反转
all	传一个list，里面的值都为真的时候返回true，否则返回false
any	传一个list，里面的值只要有一个为真， 那么就返回真
bin	10进制，转2进制的
zip	合并N个list,把它变成一个二维数组
exec	执行python代码
eval	只能执行一些简单的代码,比如定义变量、运算
map	循环调用函数，然后把list里面的每个元素传进去，保存每次的返回结果
filter	循环调用函数，然后把list里面的每个元素传进去，保存每次的返回为true的结果
round	保留几位小数

模块

模块分为以下三种：
1）标准模块：Python自带的模块
2）第三方模块：其他人已经写好的模块（如汉字转拼音-xpinyin或操作Excel的模块）
3）自己写的模块
一个模块就是一个Python文件，接下来就来看看如何在其他Python文件中导入并使用模块。

导入和使用模块

导入模块

1、import 语句

用法：import + 模块名

/import random, datetime, string, json
//		如果模块在改Python文件中没有被使用，对应的模块名称将为灰色

引入自己写的模块

新建一个文件，在其中加入变量及函数，保存为demo1后，重新打开一个Python文件，输入：import demo1
Python查找模块：Python一般先查找当前目录下有没有改模块，如果没有，则会去Python的环境变量目录下查找

//		查看Python环境变量存在哪些目录下
import sys
print(sys.path)

当自己写的模块与Python文件在同一目录或在Python环境变量目录下时

//		demo1文件内容
name = "wanshucheng"

def say_hello():
   print('hello')
print(name)
say_hello()
//		新建Python中编写的内容
import demo1
/*		输出：
wanshucheng
hello
*/

当自己写的模块不在以上路径下

//		这时需要添加相应的路径到sys.path目录下
import sys

sys.path.append("C:/Users/admin/Desktop/ABC/DES")		//	在末尾添加路径
sys.path.insert(0,"C:/Users/admin/Desktop/ABC/DES")		//	在最前面添加路径
import demo1
/*		输出：
wanshucheng
hello
*/

2、from … import …语句

from … import …语句可以从模块中导入一个指定的部分或导入全部内容到当前模块。
用法：from 模块名 import 函数名，变量名
from 模块名 import *

//		导入一个指定的部分
from demo1 import say_hello,name
//		导入所有
from demo1 import *

rom…import *尽量不要使用，因为一次性导入多个模块时候，Python会不知道到底导入的是哪个模块的内容

使用模块

random模块下的常用方法

import random

number = random.randint(1,10) 		//		生成随机整数
f = random.uniform(1,100)		//		生成随机的小数
//		print(round(f,2))		保留两位小数
l = [1,2,3,4,23,23,52,32,632,362,362,36,2362]
s = 'gslkjlk2352525'
print(random.sample(s,2)) 		//		随机选择n个元素

print(random.choice(s)) 		//		随机选择1个元素

random.shuffle(l)			 //		洗牌，没有返回值，它会改变传入list的值

random.shuffle(s)		//		会报错，该方法不能应用于字符串，因为字符串不能修改
print(l)

使用第三方或者自己写的模块

导入模块时，可以选择导入模块中所有的内容，也可以仅仅使用部分函数、变量或类

//		import方法导入模块所有内容
from demo1 import say_hello,name
tools.say_hello()
print(tools.name)
//		from … import …方法导入模块中部分方法或变量
from demo1 import say_hello,name
print(name)
say_hello()

如果自己编写的模块中，有函数跟Python自带模块名相同，可以用 取别名的方式进行区分

//		import语句
import  random as random_1

//		from … import …语句
from demo1 import random as de_random

if name == 'main’语句

如果在模块中写入if name == ‘main’，在别的Python文件调用该模块时，则if name == 'main’语句下的代码不会被执行。

//		demo1文件内容
print(__name__)
/*		输出：__main__
因此满足非空即真，if __name__ == '__main__'的语句将被执行
*/

if name == 'main’多用于自己写的模块文件中，如果一些语句在该模块中暂时不使用，但是又不想删除，可以使用该语句。

//		demo1文件内容
name = "wanshucheng"

def say_hello():
    print('hello')

if __name__ == '__main__':
    print(name)
    say_hello()
//		新建Python中编写的内容
import demo1
//		输出为空