函数、函数参数、变量、深拷贝、随机数

1. 内置函数

#内置函数

# input()
# print()
# int()
# float()
# dict()
# list()
# set()
# tuple()
# bool()
# type()
# id()
# len()

# print(bool(''))
# print(bool(None))
# print(bool([]))
# print(bool({}))
# print(bool(()))
# print(bool(0))
# print('-------------')
# print(bool('a'))
# print(bool(1))
# print(bool(1.5))
# print(bool({'age':1}))
# print(bool((1,2)))
# print(bool([1]))

res = sum([1,2,3,5,6])
max([1,2,3,5,6])
min([1,2,3,5,6])
#round()
# print(round(1.991,2))
# print(divmod(19,5))

def abc():
    a = 1
    print(locals())     #取函数里面的所有的局部变量
    print(globals())    #取整个Python文件里面的所有变量
# abc()
#
# print(globals())        #当前文件里面的变量
# print(locals())         #取当前文件里面的bian'l

#chr()#数字转换成ASCII码
#oct()
#字符集编码，让计算机认识汉字、英文字母
#0 1

# print(chr(64))      #ASCII码对应的字符
# print(ord('A'))     #字符对应的ASCII码

# dir()
# enumerate
# exec()
# filter()
# map()
# eval()
# zip()

# d = {}
# l = []
# print(dir(l))         #查看支持的方法
# print(help(d))        查看帮助

l = ['a','b','c','d','e','f']
# a=>1
# b=>2
# f=>6

# id = 1
# for i in l:
#     print('%s => %s'%(i,id))
#     id+=1

# for id,i in enumerate(l,1):
#     print('%s => %s' % (i, id))
#
# l1 = ['xiaoming','xiaobai','xiaohei']
# l2 = [110,120,119]
# l3 = [1,2,3]
# res = list(zip(l1,l2,l3))
# #print(dict(res))
# print(res)

#网页上调用Python代码运行的方式，传一些code给exec执行
code = '''
def say_hi():
    print('hi')
'''
#exec()      #运行Python代码

# exec(code)
# say_hi()

# print(eval('1+1'))  #执行简单的Python代码
# l = eval('[1,2,3,4]')
# print(l)

2. 函数参数

# def say_hello(word='hello'):
#     print(word)
#
#
# #1、必传参数（位置参数）
# #2、默认值参数
# #3、参数组
#
# say_hello()
# say_hello('hi')
#
# def op_file(file,content=None):
#     import json
#     resault = None
#     if content:
#         f = open(file,'w',encoding='utf-8')
#         #f.write(content)
#         json.dump(content,f)
#     else:
#         f = open(file,encoding='utf-8')
#         #res = f.read()
#         resault = json.load(f)
#     f.close()
#     return resault

# print(('abc'))
# print(('abc',))     #加一个逗号打印的才是元组


#写一个函数，有2个功能，能读能行文件

#1、读文件只需要知道文件名
#2、写文件，需要知道文件名和写入内容

# def op_file(file,content=None):
#     import json
#     if content:
#         with open(file,'w',encoding='utf-8') as f:
#             json.dump(content,f)
#     else:
#         with open(file,encoding='utf-8') as f:
#             return json.load(f)

#参数组
def send_mail(*names):
    #print('%s'%('abc','bcd','efg'))        #可以用format
    print(type(names))
    for name in names:
        print('给%s发邮件'%name)


#不传参数行不行
#传1个
#传2个
#传过去的是什么东西 tuple

send_mail()
send_mail('test')
send_mail('test','test1')
send_mail('test','test1',[123,123])


# def send_mail(*args):
#     ('abc','bcd','sdfad')
#     print(args)

# def szz(name,age,sex,addr,phone,qq,mail):
#     print(name,age,sex)
# #首次使用关键字传参后
# szz('meteor',sex='女',qq=198234012,phone=123024234,age=18,addr='东北',mail='asdf@163.com')

#调用函数的时候，可以全部使用位置参数，位置是一一对应的，必须按照位置来传参
#也可以全部都用关键字参数，指定关键字，不需要按照顺序来
#也可以一起用，但是要先写位置参数，再写关键字参数，关键字参数后面不能再出现位置参数
# 1、必传参数
# 2、默认值参数
# 3、参数组
# 4、关键字参数

def xiaohei(**info):        #参数放在字典里
    print(info)

# 1、参数是否必传   不必填
# 2、位置参数传参、是否可以         不可以
# 3、关键字参数传参、是否可以    可以
# 4、是否限制参数的个数   不限制

# xiaohei()
# #xiaohei(1,2,3)
# xiaohei(name='test',age=18)
# xiaohei(file_name='text.txt',mode='N',content='asdfsfd',time=1)

def xiaobai(name,age=None,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)

xiaobai('xiaobai',18,'beijng','shanghai',money=500,func='xiaobai')

#1、*args放在元组里
#2、**kwargs放在字典里

#解包
def op_mysql(host,port,user,passwd,db):
    print(host)
    print(port)
    print(user)
    print(passwd)
    print(db)

# op_mysql('127.0.0.1',3306,'root','123456','szz')
# op_mysql(host='127.0.0.1',passwd=123456)

# s='12345'
# op_mysql(*s)


db_info = ['127.0.0.1',3306,'root','123456','szz']
op_mysql(*db_info)      #（*list）解包，代表拆开这个列表或者元组,传给函数，但是参数数量要对应上，不能少也不能多,字符串也可以，有下标就行

db_info2 = {
    'host':'127.0.0.01',
    'port':3306,
    'user':'szz',
    'passwd':'123456',
    'db':'szz'
}
op_mysql(**db_info2)        #解包，要求字典内的key要与函数参数名对应上

3.函数的返回值：

# def xiaobai():
#     for i in range(100):
#         print(i)
#         return i
#
# res = xiaobai()
#
# print(res)

# def get_file(age,name,addr):
#     #当前目录下有多少个文件
#     #这些文件的文件名
#     age+=5
#     name = 'szz_'+name
#     addr = 'beijing_'+addr
#     return age,name,addr            #返回一个元组
#
# res = get_file(19,'test','天通苑')     #可以一个变量接收
# print(res,type(res))
#
# age,name,addr = get_file(19,'test','天通苑')       #可以多个变量接收
# print(age)
# print(name)
# print(addr)
#
# def add_user(username:str,password:list):
#     print('username',username)
#     print('password',password)
#
# add_user((1,2,3),'test')


#递归，函数自己调用自己，最深999次

def say():
    num = input('请输入一个数字：').strip()
    if int(num)%2!=0:
        print('请重新输入：')
        say()
say()

4.局部变量、全局变量

#局部变量   定义在函数里面的变量是局部变量，只能在函数里面使用，出了函数就不能用了
#全局变量   定义在函数外面的变量是全局变量     少用全局变量，容易影响结果，另外全局变量占用内存


# name = 'abc'
#
# money = 0

# def func():
#     name = 'abc2'       #在函数内部首先在函数内部去找变量，然后才去看全局变量
#     age = 38
#     print(age)
#     print('1',name)
#
# func()
#
# print('2',name)

# def dsk():
#     global money        #声明改变的是全局变量
#     money+=500
#
# def ldd():
#     global money
#     money-=100
#
# print('调用之前的',money)
# dsk()
# print('挣钱之后的',money)
# ldd()
# print('花钱之后的',money)

# money = 500
#
# def test(consume):
#     return money - consume
#
# def test1(money):
#     return test(money) + money
#
# money = test1(money)
#
# print(money)

# def test():
#     global a
#     a = 5
#
# def test1():
#     c = a + 5
#     return c
# #test()             #未调用test()之前没有定义a，报错，调用后，定义了a，返回正确结果
# res = test1()
# print(res)
#

stus = ['xiaojun','xiaohei','xiaobai']
stu_info = {
    'name':'xiaojun',
    'age':19
}
stus2 = {'xiaohei','xiaobai'}


#int str tuple需要global声明
#可变类型：字典、list、set
#不可变类型：int、string、tuple
def add_stu():
    name = input('name:')
    age = input('age:')
    stus.append(name)
    stu_info[name] = age


def select_stu():
    name = input('name:')
    print('你的学号是%s'%stus.index(name))

select_stu()

5.深拷贝

# var = [1,2,3,4]
# var[1] = 5
#
# var1 = 'abc123'
# var1[0] = 's'
#
# var2 = ('a','b','c','d')
# var2[-1] = 2
# var2 = ('a','b','c',2,'d')
#
# var3 = {'a',3,'b','4'}
# var3[2] = 'c'
#
# var4 = {'name':'lily','sex':'nv'}
# print(var4['age'])
# print(var4.get('age'))

li = [1,1,2,3,4,5,6,7,8,9]
l2 = [1,1,2,3,4,5,6,7,8,9]
l4 = li[:]
l3 = li
print(id(li))
print(id(l2))
print(id(l3))
print(id(l4))
#内存地址不同，重命名或者切片获取数值可以得到不同的内存地址

for i in l2:
    if i%2!=0:
        li.remove(i)
print(li)

#循环删除list的时候，都会出现这样的问题
#循环的时候，不要删除元素，下标会错乱

#深拷贝
#浅拷贝
li = [1,1,2,3,4,5,6,7,8,9]
l4 = li[:]                      #深拷贝
l3 = li                         #浅拷贝
# print(l3)
# l3.pop()
# print(l3)
# print(li)

#深拷贝和浅拷贝的区别，浅拷贝不会开辟新的内存地址，深拷贝会开辟新的内存地址

import copy
# d = {'name':'xiaohei'}
# #d1 = d      #浅拷贝
# d1 = copy.deepcopy(d)#深拷贝
# d1['age']=18
# print(id(d))
# print(id(d1))
# print('d',d)
# print('d1',d1)

d = {'name':'xiaohei','l':[4,5,6]}
#d1 = d      #浅拷贝
d1 = copy.deepcopy(d)#深拷贝  copy.copy()只能作用一层，多层时没作用,只能用deepcopy()做深拷贝
d1['age']=18
d1['l'].append(8)
print(id(d))
print(id(d1))
print('d',d)
print('d1',d1)

6.随机数

import random

random.randint(1,100)

l = [1,2,3,4,5,6,4,3,2]
#print(random.sample(['a','b','c'],2))      #随机取两个元素
# print(random.choice(l))             #随机取一个元素
# print(random.uniform(1,19))         #随机取一个小数

random.shuffle(l)       #把list顺序打乱
print(l)