计算机基本的硬件由：CPU / 内存 / 主板 / 硬盘 / 网卡 / 显卡 等组成，只有硬件但硬件之间无法进行交流和通信。需要操作系统进行协调工作
操作系统用于协同或控制硬件之间进行工作，常见的操作系统有那些:
编程语言的开发者写的一个工具，将用户写的代码转换成010101交给操作系统去执行。
解释型语言就类似于： 实时翻译，代表：Python / PHP / Ruby / Perl
编译型语言类似于：说完之后，整体再进行翻译，代表：C / C++ / Java / Go ...
软件又称为应用程序，就是我们在电脑上使用的工具，类似于：记事本 / 图片查看 / 游戏
对于计算机而言无论是文件存储 / 网络传输输入本质上都是：二进制（010101010101），如：电脑上存储视频/图片/文件都是二进制； QQ/微信聊天发送的表情/文字/语言/视频 也全部都是二进制。
进制：
输入
输出
对于Python默认解释器编码：
如果想要修改默认编码，则可以使用：
# -*- coding:utf-8 -*- 注意：对于操作文件时，要按照：以什么编写写入，就要用什么编码去打开。
问：为什么要有变量？
为某个值创建一个“外号”，以后在使用时候通过此外号就可以直接调用。
基本结构
if 条件 :
结果
else:
结果while循环基本结构;
while 条件:
结果
# 如果条件为真，那么循环则执行
# 如果条件为假，那么循环不执行debug模式显示每一步运行结果;
关键字
(公共功能)
for循环基本结构
for 新变量 in 原变量:
? 结果 ----------------循环取出原变量的字符赋值给新变量
name = 'bigox'
for new_name in name:
print(new_name)range界限
# range(1,5,1) #第一个参数是范围的起始位置,第二个参数是范围的结束位置,第三个为步长,默认为1,取值顾首不顾尾.
for num in range(1,9):
print(num) #=======>输出为1-8算数运算
比较运算
赋值运算
逻辑运算
and "与"
v = 1 and 9 =====> v = 9 #如果第一个值转换为布尔值时如果为True,则v=第二个值;
v1 = 0 and 1 =====> v = 0 #如果第一个值转换为布尔值时如果为False,则v=第一个值;
v1 = 0 and '' =====> v = 0 #如果有多个and,从左到右进行判断.or "或"
v = 1 or 9 =====> v = 1 #如果第一个值转换为布尔值时如果为True,则v=第一个值;
v1 = 0 or 1 =====> v = 1 #如果第一个值转换为布尔值时如果为False,则v=第二个值;
v1 = 0 or '' =====> v = '' #如果有多个or,从左到右进行判断.not "非"
补充:
in / not in
#示例:(是否包含敏感字符)
while True:
text = input('请输入你要说的话:')
if '傻逼'in text:
print('包涵敏感字符')py2中有：int/long
py3中有：int （int/long）
py2和py3中整除是不一样。
py2除法只能取整数,py3除法取全部值
py2除法取全部值,需要加代码:
from future improt division
value = 3/2
print(value)
布尔值就是用于表示真假。True和False。
其他类型转换成布尔值：
对于：None / "" / 0 .... -> false
字符串是写代码中最常见的，python内存中的字符串是按照：unicode 编码存储。对于字符串是不可变。
\n换行符
基本格式
name = input('请输入姓名:')
age = input('请输入年龄:')
job = input('请输入工作:')
hobby = input('请输入爱好:')
msg = '''
---------- info of bigox ----------
Name :%s
Age :%s
Job :%s
Hobby :%s
------------- end -------------'''
print(msg%(小钻风,500,it,girl,))
注意要点:
1.input 输入内容全是字符串.
2.py版本输入格式区别
字符串 str:upper/lower/isdecimal/strip/replace/split/startswith/endswith/format/encode/join
大写： upper
v = 'ALEX'
v1 = v.upper()
print(v1)
v2 = v.isupper() # 判断是否全部是大写
print(v2)小写：lower
v = 'alex'
v1 = v.lower()
print(v1)
v2 = v.islower() # 判断是否全部是小写
print(v2)
############ 了解即可
v = '?'
# 将字符串变小写（更牛逼）
v1 = v.casefold()
print(v1) # ss
v2 = v.lower()
print(v2)判断是否是数字： isdecimal
v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit() # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)
# 推荐用 isdecimal 判断是否是 10进制的数。
# ############## 应用 ##############
v = ['alex','eric','tony']
for i in v:
print(i)
num = input('请输入序号：')
if num.isdecimal():
num = int(num)
print(v[num])
else:
print('你输入的不是数字')
去空白+\t+\n + 指定字符串.strip()
v1 = "alex "
print(v1.strip())
v2 = "alex\t"
print(v2.strip())
v3 = "alex\n"
print(v3.strip())
v1 = "alexa"
print(v1.strip('al'))
替换 replace
#.replace()
message = input('请输入"大傻逼"')
new_mes = message.replace('傻逼','**')
print(new_mes)
#.replace('原字符','替换字符','替换个数')
.startswith() 判断是否以()开头,输出值为bool类型
name = 'bigox'
print(name.startswith('big'))
.endswith() 同.startswith()用法相同
.format()格式(同字符串格式化)
name = '我叫:{0},年龄:{1}'.format('bigox',24)
print(name)
name = '刘' #解释器读取到内存后,按照unicode编码存储:8字节.
print(name.encode('utf-8')) #转化为utf-8编码
? 10 .join()循环每个元素,并在元素之间加入连接符.
name = 'bigox'
new_name = '_'.join(name)
print(new_name) #输出结果为 b_i_g_o_x
分割:字符串切割后形成列表
#.split()
name = 'abcdefg'
new_name = name.split('d')
print(new_name)
#.split('分割点',分割次数)
列表独有方法
** .append()列表最后追加元素**
lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]
print(lst)
lst.append("wusir")
print(lst)
.insert在指定的索引位置插入元素
lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]
print(lst)
lst.insert(1,"wusir")
print(lst)
.remove()指定元素删除
.remove("指定元素")
.pop()删除索引元素:()如果没有索引值的话默认删除出最后一个
.pop(索引)
.clear()清空
del[ ]切片删除
.extend()添加
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
s = 'qwert'
li.extend(s)
print(li)
#---------------------------
lst = ["王志文", "张一山", "苦海无涯"]
lst.extend(["麻花藤", "麻花不疼"])
print(lst)
reverse反转
v = [1,2,3,4,5,6]
v.reverse()
print() #[6, 5, 4, 3, 2, 1]
v = [1,3,7,4,5,6]
v.sort()
print() #[1, 3, 4, 5, 6, 7]
#v.sort() 从小到大排序(默认)
#v.sort(reverse=True) 从大到小排序
列表转字符串:
nums = [11,22,33,44]
for a in range(0,len(nums)):
nums[a] = str(nums[a])
result = ''.join(nums)
print(result)
3.5元组tuple
元组为不可变类型
元组子元素不可变,而子元素内部的子元素是可以变的,取决于元素是否为可变对象
元组中如果只有一个元素,一定要添加一个逗号,否者不是元组(1,)
可嵌套
字典:帮助用户表示事物的信息(事物有多个属性)
基本格式:字典键的数据类型不能为list和tuple,值可以为任何类型.
dictionary = {'键':'值','键':'值','键':'值'}
独有功能:
info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}获取字典info所有键.keys()
for i in info.keys():
print(i)获取字典info所有值.values()
for i in info.values():
print(i)获取字典info所有的键值对.items()
for i in info.items():
print(i).get()取值
info = {'k1':'v1','k2':'v2'}
a = info.get('k1')
print(a) #v1
info2 = ['11111']
b = info.get('11111',22222)
print(b) #22222.update()更新,存在就更改,不存在增加
info = {'k1':'v1','k2':'v2'}
info.update({'k1':'v0','k3':'v3'})
print(info) #{'k1': 'v0', 'k2': 'v2', 'k3': 'v3'}****判断是否存在敏感字符
in/not in 是否包涵(输出类型为bool类型)
str/list/tuple/dict都适用
# # 经典例题 # #
# 让用户输入任意字符串，然后判断此字符串是否包含指定的敏感字符。
#char_list = ['利奇航','堂有光','炸展会']
#content = input('请输入内容：') # 我叫利奇航 / 我是堂有光 / 我要炸展会
char_list = ['利奇航','堂有光','炸展会']
i = True
content = input('请输入内容:')
for mes in char_list:
if mes in content:
i = False
break
if i:
print(无敏感字符)
else:
print(包含敏感字符)
集合独有功能,
.add() 添加
.discard()删除
要修改,需要先删除再添加
.clear()清空
.update()
info = {'k1','k2'}
info.update({'k1','k3','v3'})
print(info) #{'k1','k2','k3','v3'}
.intersection() 交集
? 命令后的 () 可以是集合,也可以是列表.
info = {1,2,3}
print(info.intersection({1,3,4})) #{1,3}
.union()并集
info = {1,2,3}
print(info.union({1,3,4})) #{1,2,3,4}
.difference()差集
info = {1,2,3}
print(info.union({1,3,4})) #{2,4}
id(查看内存地址)
赋值更改内存地址,内部变更改变量的值
内存地址
a = 1
b = 1
id(a) = id(b)
#按理说a与b的id不该一样,但是在python中,为了提高运算性能,对某些特殊情况进行了缓存.(小数据池)缓存对象:
1. 整型： -5 ~ 256
2. 字符串："alex",'asfasd asdf asdf d_asdf ' ----"f_*" * 3 - 重新开辟内存。
== 与is 区别
对str,int,bool,tuple不可变数据类型深浅拷贝都一样,对于list,dict,set可变数据类型才有区别
############## 示例 ############
v1 = 'alex'
import copy #固定格式
v2 = copy.copy(v1)
print(id(v1),id(v2))
浅拷贝 copy.copay()
深拷贝 copy.deepcopy()
一.数字/整型int
二.bool类型False&True
三.字符串str
str()强行转化字符串
#列表转化字符换
nums = [11,22,33,44]
for a in range(0,len(nums)):
nums[a] = str(nums[a])
result = ''.join(nums)
print(result)
.upper()转化大写
name = 'abc'
new_name = name.upper()
print(new_name)
.lower()转化小写
name = 'ABC'
new_name = name.lower()
print(new_name)
.replace()替换
message = input('请输入"大傻逼"')
new_mes = message.replace('傻逼','**')
print(new_mes)
#.replace('原字符','替换字符','替换个数')
.strip()去首尾空格
name = ' abc '
new_name = name.strip()
print(new_name)
#.rstrip()去除右侧空格 .lstrip()去除左侧空格
.split()分割
name = 'abcdefg'
new_name = name.split('d')
print(new_name)
#.split('分割点',分割次数)
.isdecimal()判断是否可以转化位数字
while True:
num = input('请输入内容:')
num1= num.isdigit() #print(num1) 数字的话输出True,非数字输出FALSE
if num1:
print('你输入正确')
break
else:
print('请输入数字')
.startswith() 判断是否以()开头,输出值为bool类型
name = 'bigox'
print(name.startswith('big'))
endswith() 判断是否以()结尾,输出值为bool类型 同.startswith()用法相同
.format()格式(同字符串格式化)
name = '我叫:{0},年龄:{1}'.format('bigox',24)
print(name)
.encode() :编码转换
name = '刘' #解释器读取到内存后,按照unicode编码存储:8字节.
print(name.encode('utf-8')) #转化为utf-8编码
.join()循环每个元素,并在元素之间加入连接符.
name = 'bigox'
new_name = '_'.join(name)
print(new_name) #输出结果为 b_i_g_o_x
四.列表list
列表转换list()
#列表转化字符换
nums = [11,22,33,44]
for a in range(0,len(nums)):
nums[a] = str(nums[a])
result = ''.join(nums)
print(result)
.pop(索引)
a = li.pop(2) #在列表中删除,并将删除的此数据赋值给a
name = ['bigox','xo','ox']
name.pop(1)
print(name)
del 列表 [索引]
name = ['bigox','xo','ox']
del name[0:2]
print(name)
.append()列表最后追加元素
lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]
print(lst)
lst.append("wusir")
print(lst)
.insert()在指定的索引位置插入元素
lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]
print(lst)
lst.insert(1,"wusir")
print(lst)
remove()**指定元素删除
name = ['bigox','xo','ox']
name.remove(xo)
print(name)
.clear()**清空
.extend**()添加
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
s = 'qwert'
li.extend(s)
print(li)
#---------------------------
lst = ["王志文", "张一山", "苦海无涯"]
lst.extend(["麻花藤", "麻花不疼"])
print(lst)
.reverse()反转
v = [1,2,3,4,5,6]
v.reverse()
print() #[6, 5, 4, 3, 2, 1]
.sort排序
v = [1,3,7,4,5,6]
v.sort()
print() #[1, 3, 4, 5, 6, 7]
#v.sort() 从小到大排序(默认)
#v.sort(reverse=True) 从大到小排序
五.元组tuple
强制转换：
tuple(‘adfadfasdfasdfasdfafd‘)
v1 = tuple('adfadfasdfasdfasdfafd')
print(v1) # ('a', 'd', 'f', 'a', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's', 'd', 'f', 'a', 's', 'd', 'f', 'a', 'f', 'd')
tuple([11,22,33,44])
v1 = tuple([11,22,33,44])
print(v1) # (11, 22, 33, 44)
元组子元素不可变,而子元素内部的子元素是可以变的,取决于元素是否为可变对象
元组中如果只有一个元素,一定要添加一个逗号,否者不是元组
六.字典dict
字典键的数据类型不能为list和tuple,值可以为任何类型.
.keys()取键
for i in info.keys():
print(i)
.values()取值
for i in info.values():
print(i)
.items()取键值对
for i in info.items():
print(i)
.get()以键取值,如果键不存在返回原定结果
info = {'k1':'v1','k2':'v2'}
a = info.get('k1')
print(a) #v1
info2 = ['11111']
b = info.get('11111',22222)
print(b) #22222
.update()更新_存在覆盖更新,不存在添加
info = {'k1':'v1','k2':'v2'}
info.update({'k1':'v0','k3':'v3'})
print(info) #{'k1': 'v0', 'k2': 'v2', 'k3': 'v3'}
七.集合set
无序,不可重复
在集合中True与数字1重复,False与数字0重复
.add() 添加
info = {'k1','k2'}
info.add('k3')
print(info)
.discard()删除
info = {'k1','k2','k3'}
info.discard('k3')
print(info)
要修改,需要先删除再添加
.clear()清空
.update()
info = {'k1','k2'}
info.update({'k1','k3','v3'})
print(info) #{'k1','k2','k3','v3'}
.intersection() 交集
? 命令后的 () 可以是集合,也可以是列表.
info = {1,2,3}
print(info.intersection({1,3,4})) #{1,3}
.union()并集
info = {1,2,3}
print(info.union({1,3,4})) #{1,2,3,4}
.difference()差集
info = {1,2,3}
print(info.union({1,3,4})) #{2,4}
obj = open('路径',mode='模式',encoding='编码')
obj.write()
obj.read()
obj.close()
基本模式
#打开文件
f=open('要打开文件路径',mode='r/w/a/',encoding='文件原来编码') #f为接收变量
#操作文件
data = f.() # 读取文件内部全部内容,data为接收内容
f.write('要写内容')
#关闭文件
f.close()
#文件打开新操作,自动关闭
with open('text.txt',mode= 'a',encoding='utf-8') as v:
data = a.read()
# 缩进中的代码执行完毕之后自动关闭
r / w / a
r+ / w+ / a+
rb / wb / ab
r+b / w+b / a+b
w/wb
w 模式传入的是字符串,写入时计算机进行了两步操作:
将写入内容根据指定编码encoding转换为对应二进制语言
# 字符串转化为二进制
mes = '示例'
a = mes.encode('utf-8')
#二进制文件转化为字符串
mes = '01010101010100'
a = mes.decode('utf-8')
将二进制写入到文件里
wd 模式传入的是二进制文件,想写入字符串需要进行转换操作
r/rb
a/ab
read() , 全部读到内存
read(1)
1表示一个字符
obj = open('a.txt',mode='r',encoding='utf-8')
data = obj.read(1) # 1个字符
obj.close()
print(data)
1表示一个字节
obj = open('a.txt',mode='rb')
data = obj.read(3) # 1个字节
obj.close()
write(字符串)
obj = open('a.txt',mode='w',encoding='utf-8')
obj.write('中午你')
obj.close()
write(二进制)
obj = open('a.txt',mode='wb')
# obj.write('中午你'.encode('utf-8'))
v = '中午你'.encode('utf-8')
obj.write(v)
obj.close()
seek(光标字节位置)，无论模式是否带b，都是按照字节进行处理。
obj = open('a.txt',mode='r',encoding='utf-8')
obj.seek(3) # 跳转到指定字节位置
data = obj.read()
obj.close()
print(data)
obj = open('a.txt',mode='rb')
obj.seek(3) # 跳转到指定字节位置
data = obj.read()
obj.close()
print(data)tell(), 获取光标当前所在的字节位置
obj = open('a.txt',mode='rb')
# obj.seek(3) # 跳转到指定字节位置
obj.read()
data = obj.tell()
print(data)
obj.close()flush，强制将内存中的数据写入到硬盘
v = open('a.txt',mode='a',encoding='utf-8')
while True:
val = input('请输入：')
v.write(val)
v.flush()
v.close()文艺
v = open('a.txt',mode='a',encoding='utf-8')
v.close()二逼
with open('a.txt',mode='a',encoding='utf-8') as v:
data = v.read()
# 缩进中的代码执行完毕后，自动关闭文件
with open('a.txt',mode='r',encoding='utf-8') as f1:
data = f1.read()
new_data = data.replace('飞洒','666')
with open('a.txt',mode='w',encoding='utf-8') as f1:
data = f1.write(new_data)
with open('a.txt',mode='r',encoding='utf-8') as f1,open('b.txt',mode='w',encoding='utf-8') as f2: #打开文件a,b
for line in f1: #按行取a的内容
new_line = line.replace('666','999') #修改内容
f2.write(new_line) #修改后的写入b,完成修改
三元(目)运算:
v = 前面 if 条件 else 后面 #条件为真v=前面,条件为假v=后面
#等同于
if 条件：
v = '前面'
else:
v = '后面'
#示例:
# 让用户输入值，如果值是整数，则转换成整数，否则赋值为None
data = input('>>>')
value = int(data) if data.isdecimal() else None
函数定义:函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。
def 函数名():
# 函数内容
pass #pass占位符,没有任何操作
# 函数的执行
函数名()
函数如果不被调用,内部代码将不被执行.
运行示例
def get_list_first_data():
v = [11,22,33,44]
print(v[0])
get_list_first_data()
参数分为动态参数和静态参数,又叫动参和形参.
def get_list_first_data(aaa): # aaa叫形式参数(形参)
v = [11,22,33,44]
print(v[aaa])
get_list_first_data(1) # 2/2/1调用函数时传递叫：实际参数（实参）
小练习
# 1. 请写一个函数，函数计算列表 info = [11,22,33,44,55] 中所有元素的和。
def get_sum():
info = [11,22,33,44,55]
data = 0
for item in info:
data += item
print(data)
get_sum()
# 2. 请写一个函数，函数计算列表中所有元素的和。
def get_list_sum(a1):
data = 0
for item in a1:
data += item
print(data)
get_list_sum([11,22,33])
get_list_sum([99,77,66])
v1 = [8712,123,123]
get_list_sum(v1)
# 3. 请写一个函数，函数将两个列表拼接起来。
def join_list(a1,a2):
result = []
result.extend(a1)
result.extend(a2)
print(result)
join_list([11,22,33],[55,66,77]
# 4. 计算一个列表的长度
def my_len(arg):
count = 0
for item in arg:
count += 1
print(count)
v = [11,22,33]
my_len(v)
len(v)
return后续代码不会被执行
只能返回一次
如果要返回多个数据，可先把多个数据包装成一个整体。整体返回（列表、元组、字典.......）
def caculate(a, b):
he = a + b
cha = a - b
return (he, cha)
小练习
# 1. 让用户输入一段字符串，计算字符串中有多少A字符的个数。有多少个就在文件a.txt中写多少个“李邵奇”。
def get_char_count(data):
sum_counter = 0
for i in data:
if i == 'A':
sum_counter += 1
return sum_counter
def write_file(line):
if len(line) == 0:
return False # 函数执行过程中，一旦遇到return，则停止函数的执行。
with open('a.txt',mode='w',encoding='utf-8') as f:
f.write(line)
return True
content = input('请输入:')
counter = get_char_count(content)
write_data = "李邵奇" * counter
status = write_file(write_data)
if status:
print('写入成功')
else:
print('写入失败')
# 2. 写函数，计算一个列表中有多少个数字，打印： 列表中有%s个数字。
# 提示：type('x') == int 判断是否是数字。
"""
# 方式一：
def get_list_counter1(data_list):
count = 0
for item in data_list:
if type(item) == int:
count += 1
msg = "列表中有%s个数字" %(count,)
print(msg)
get_list_counter1([1,22,3,'alex',8])
# 方式二：
def get_list_counter2(data_list):
count = 0
for item in data_list:
if type(item) == int:
count += 1
return count
v = get_list_counter1([1,22,3,'alex',8])
msg = "列表中有%s个数字" %(v,)
print(msg)
"""
# 2. 写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回。
"""
# 方式一：
def get_data_list1(arg):
v = arg[::2]
return v
data = get_data_list1([11,22,33,44,55,66])
# 方式二：
def get_data_list2(arg):
v = []
for i in range(0,len(arg)):
if i % 2 == 0:
v.append(arg[i])
return v
data = get_data_list2([11,22,33,44,55,66])
"""
# 3. 读取文件，将文件的内容构造成指定格式的数据，并返回。
"""
a.log文件
alex|123|18
eric|uiuf|19
...
目标结构：
a. ["alex|123|18","eric|uiuf|19"] 并返回。
b. [['alex','123','18'],['eric','uiuf','19']]
c. [
{'name':'alex','pwd':'123','age':'18'},
{'name':'eric','pwd':'uiuf','age':'19'},
]
"""
#c问答案:
def read_log(txt):#定义函数
l=['name','age','job']
l1 = []
with open(txt, mode='r', encoding='utf-8') as f:
for mes in f:#取f行,'alex|123|18','eric|uiuf|19'
count=0
dic={}
for v in mes.strip().split('|'):#mes.split()切割字符串['alex','123','18']
dic[l[count]]=v #取键赋值
count +=1
l1.append(dic)
print(l1)
read_log('a.log')
实际参数可以是任何值
函数没有返回值,默认返回None
函数内部执行时,遇到return就终止运行
return可以返回任何数据类型的值,多个值时返回元组
# enconding: utf-8
def test():
return 1,2,3
print(test()) #(1, 2, 3)
传参:调用函数并传递参数,实参与形参必须一一对应
位置传参:严格按照位置先后顺序传参
关键字传参:直接赋值传参,无先后顺序
混合传参:位置参数与关键字参数混合使用,位置参数一定在关键字参数之前
def func(a1, a2):
print(a1, a2)
func(a2=99,a1=2)
# 关键字传参数和位置传参可以混合使用（位置传入的参数 > 关键字参数在后 = 总参数个数）
def func1(a1, a2, a3):
print(a1, a2, a3)
# func(1, 2, a3=9)
# func(1, a2=2, a3=9)
# func(a1=1, a2=2, a3=9)
# func(a1=1, 2,3) # 错误
(*args)只接收位置参数
格式(*参数)可以接收多个参数,但是只支持位置传参
实参传递到形参时是以元组形式传递
传参时实参前加星(*实参),先把实参打散,再传参到形参
def func(*args):
print(args)
func(1)
func(1,2) # args=(1, 2)
func((11,22,33,44,55)) # args=((11,22,33,44,55),)
func(*(11,22,33,44,55)) # args=(11,22,33,44,55)
**(kwargs)
只接收关键
字参数
实参传递到形参时是以字典形式传递{‘k‘=v}
传参时实参前加**,直接传递字典
def func(*args,**kwargs):
print(args,kwargs)
# func(1,2,3,4,5,k1=2,k5=9,k19=999)
func(*[1,2,3],k1=2,k5=9,k19=999)
func(*[1,2,3],**{'k1':1,'k2':3})
func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})
注意:一般*args与**kwargs一起使用,这是超级无敌万能参数
经典例题:
# def func(*args,**kwargs):
# print(args,kwargs)
# # a. 执行 func(12,3,*[11,22]) ，输出什么？
# # b. 执行 func(('alex','武沛齐',),name='eric')
'''a.(12,3,11,22) {}
b.(('alex','武沛齐'),) {'name':'eric'}'''
参数重点总结
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。
python
作用域中查找数据规则:优先查找自己局域内数据,自己没有再去父级作用域查找,以此类推,可以找到,可以修改,不能为父级作用域的变量重新赋值.
global ‘全局,全球‘强制更改全局作用作用域 ,先global+变量,再对变量赋值
nonlocal ‘外地‘ 强制更改父级作用域变量 ,先nonlocal+变量,再对变量赋值
# 示例一
name = ["老男孩",'alex']
def func():
global name
name = '我'
func()
print(name)
# ############################## nonlocal
name = "老男孩"
def func():
name = 'alex'
def inner():
nonlocal name # 找到上一级的name
name = 999
inner()
print(name)
func()
print(name)全局作用域:全局作用域内的数据公用
局部作用域:局部作用域可以使用全局作用域内的数据,但是全局作用域使用不了局部作用域的数据即
函数的作用域链：小范围作用域可以使用大范围的变量，但是反之不行，他是单向的。
函数内只可以调用全局作用域的函数
# x = 10
# def func():
# x = 9
# print(x)
# def x1():
# x = 999
# print(x)
# print(x)
# x1()
#
# func()
# x = 10
# def func():
# x = 8
# print(x)
# def x1():
# x = 999
# print(x)
# x1()
# print(x)
#
# func()
# x = 10
# def func():
# x = 8
# print(x)
# def x1():
# print(x)
# x1()
# print(x)
#
# func()
# x = 10
# def func():
# x = 8
# print(x)
# def x1():
# print(x)
# x = 9
# x1()
# x = 10
# print(x)
#
# func()
作用域小结
函数可以当做变量来使用:
def func():
print(123)
func_list = [func, func, func]
# func_list[0]()
# func_list[1]()
# func_list[2]()
for item in func_list:
v = item()
print(v)
函数可以当做参数进行传递,谁调用的函数返回值就给谁.
def func(arg):
print(arg)
func(1)
func([1,2,3,4])
def show():
return 999
func(show)
子作用域只能读取或修改父级的值，不能重新赋值。
#经典例题 ---------------企业面试题--------
def func():
print('花费查询')
def bar():
print('语音沟通')
def base():
print('xxx')
def show():
print('xxx')
def test():
print('xxx')
info = {
'f1': func,
'f2': bar,
'f3':base,
'f4':show,
'f5':test
}
choice = input('请选择要选择功能：')
function_name = info.get(choice)
if function_name:
function_name()
else:
print('输入错误')函数当做返回值
高级一点的内置函数(了解,懂什么意思)
map(函数,可迭代对象),映射函数,循环每个元素,然后让每个元素执行函数,将每个函数执行的结果保存到新的列表,并返回.
v1 = [11,22,33,44]
result = map(lambda x:x+100,v1)
print(list(result)) # 特殊fifter(函数,可迭代对象),筛选过滤,循环每个元素然后执行函数,将每个函数执行的结果筛选保存到新的列表并返回.
result = filter(lambda x: True if type(x) == int else False ,v1)
print(list(result))
result = filter(lambda x: type(x) == int ,v1)
print(list(result))reduce(函数,可迭代对象),循环每个元素,然后执行函数,将每个函数执行的结果删选保存到新的列表并返回.
import functools
v1 = ['wo','hao','e']
def func(x,y):
return x+y
result = functools.reduce(func,v1)
print(result)
result = functools.reduce(lambda x,y:x+y,v1)
print(result)# 三元运算，为了解决简单的if else的情况，如：
if 1 == 1:
a = 123
else:
a = 456
a = 123 if 1 == 1 else 456 #经典格式
# lambda表达式，为了解决简单函数的情况，如：
def func(a1,a2):
return a1 + 100
func = lambda a1,a2: a1+100 #经典格式列表所有方法返回值基本都是None,出了pop会返回要删除的元素
字符串所有方法返回值基本都是新值
# 练习题
USER_LIST = []
func1 = lambda x: USER_LIST.append(x)
v1 = func1('alex')
print(v1)
print(USER_LIST)
# 练习题
func1 = lambda x: x.split('l')
v1 = func1('alex')
print(v1)
自定义函数:自我编写函数.
内置函数:python系统内置函数.
lambda表达式也叫匿名函数.
函数与函数之间的数据互不影响,每次运行函数都会开一个辟新的内存.
item = 10
def func():
item = 2
def inner():
print(item)
for item in range(10):
pass
inner()
func()| 内置函数 | 含义 |
|---|---|
| len,open,range,id,type print,input,强制转换命令 | ... |
| abs() | 绝对值 |
| float() | 浮点型 |
| max() | 最大值 |
| min() | 最小值 |
| sum() | 求和 |
| divmod() | 两数相除的商和余数(页面选择) |
| pow() | 指数运算pow(2,3)= 2**3=8 |
| bin() | 十进制转化为二进制 |
| oct() | 十进制转化为八进制 |
| int() | 其他进制转化为十进制 |
| hex() | 十进制转化为十六进制 |
| chr() | 十进制数字转换成unicode编码中的对应字符串 |
| ord() | 根据字符在unicode编码中找到其对应的十进制 |
len,open,range,id,type
print,input
强制转换
数学相关
abs，绝对值
v = abs(-1)
print(v)float，转换成浮点型（小数）
v = 55
v1 = float(55)
print(v1)max，找到最大值
v = [1,2,311,21,3,]
result = max(v)
print(result)min，找最小值
v = [1,2,311,21,3,]
result = min(v)
print(result)sum，求和
v = [1,2,311,21,3,]
result = sum(v)
print(result)divmod，两数相除的商和余数
a,b = divmod(1001,5)
print(a,b)# 经典______________练习题 请通过分页对数据进行展示
"""
要求：
每页显示10条数据
让用户输入要查看的页面：页码
"""
USER_LIST = []
for i in range(1,836):
temp = {'name':'你少妻-%s' %i,'email':'123%s@qq.com' %i }
USER_LIST.append(temp)
# 数据总条数
total_count = len(USER_LIST)
# 每页显示10条
per_page_count= 10
# 总页码数
max_page_num,a = divmod(total_count,per_page_count)
if a>0:
max_page_num += 1
while True:
pager = int(input('要查看第几页：'))
if pager < 1 or pager > max_page_num:
print('页码不合法，必须是 1 ~ %s' %max_page_num )
else:
"""
# 第1页：USER_LIST[0:10] -> 0123456789
# 第2页：USER_LIST[10:20]
# 第3页：USER_LIST[20:30]
...
"""
start = (pager-1) * per_page_count
end = pager * per_page_count
data = USER_LIST[start:end]
for item in data:
print(item)进制转换:
十进制数转化为其他进制时十进制数必须是整型.
其他进制转化为十进制时其他进制数必须是字符串,并在字符串后注明多少进制.
bin，将十进制转化成二进制
num = 13
v1 = bin(num)
print(v1)oct，将十进制转换成八进制,
num = 8
v1 = oct(num)
print(v1)int，将其他进制转化成十进制
# 二进制转化成十进制
v1 = '0b1101'
result = int(v1,base=2)
print(result)
# 八进制转化成十进制
v1 = '0o1101'
result = int(v1,base=8)
print(result)
# 十六进制转化成十进制
v1 = '0x1101'
result = int(v1,base=16)
print(result)hex，将十进制转换成十六进制
num = 16
v1 = hex(num)
print(v1)----企业面试题------
# 1字节等于8位
# IP: 192.168.12.79 -> 001010010 . 001010010 . 001010010 . 001010010
# 1. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串。
ip = "192.168.12.79"
ip_list = ip.split('.') # ['192','168','12','79']
result = []
for item in ip_list:
result.append(bin(int(item)))
print(','.join(result))
# 2. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制:
# 0010100100001010010001010010001010010 -> 十进制的值。
# 3232238671应用场景:
函数可以作为变量
函数可以作为参数
函数可以作为返回值
def bar():
def inner():
print(123)
return inner
v = bar()
v()闭包:为一个函数创建一块区域(内部变量供自己使用),为他以后执行提供数据
# 基本格式
def func(name):
def inner():
print(name)
return inner
v1 = func('alex')
v1()
v2 = func('eric')
v2()#练习
# 第一题
name = 'alex'
def base():
print(name)
def func():
name = 'eric'
base()
func() # {name=eric, }
# 第二题
name = 'alex'
def func():
name = 'eric'
def base():
print(name)
base()
func()
# 第三题
name = 'alex'
def func():
name = 'eric'
def base():
print(name)
return base
base = func()
base()
闭包企业面试题
info = []
def func(i):
def inner():
print(i)
return inner
for item in range(10):
info.append(func(item))
info[0]()
info[1]()
info[4]()1.将指定的字符串加密:
import hashlib
def get_md5(data):
obj = hashlib.md5()
obj.update(data.encode('utf-8'))
result = obj.hexdigest()
return result
val = get_md5('123')
print(val)加盐
import hashlib
def get_md5(data):
obj = hashlib.md5("sxff123ad".encode('utf-8'))#md5(加入任意字符串增加密码复杂度)
obj.update(data.encode('utf-8'))
result = obj.hexdigest()
return result
val = get_md5('123')
print(val)应用:
#账户密码加密函数:
import hashlib
USER_LIST = []
def get_md5(data):
obj = hashlib.md5("gfdsjdxff123ad".encode('utf-8'))
obj.update(data.encode('utf-8'))
result = obj.hexdigest()
return result
#用户注册:
def register():
print('**************用户注册**************')
while True:
user = input('请输入用户名:')
if user == 'N':
return
pwd = input('请输入密码:')
temp = {'username':user,'password':get_md5(pwd)}
USER_LIST.append(temp)
#用户登录
def login():
print('**************用户登陆**************')
user = input('请输入用户名:')
pwd = input('请输入密码:')
for item in USER_LIST:
#校验新输入密码加密后与用户注册加密是否相同
if item['username'] == user and item['password'] == get_md5(pwd):
return True
register()
result = login()
if result:
print('登陆成功')
else:
print('登陆失败')2.随机验证码模块应用:
#生产随机验证码
import random
def get_random_code(length=6):
data = []
for i in range(length):
v = random.randint(65,90) #random.randit(最小值,最大值) 生产随机数
data.append(chr(v))
return ''.join(data)
code = get_random_code()
print(code)
import random # 导入一个模块
v = random.randint(起始,终止) # 得到一个随机数
3.密码不显示（只能在终端运行）
import getpass
pwd = getpass.getpass('请输入密码：')
if pwd == '123':
print('输入正确')
认识苦短,我学Python.每日持续更新
原文：https://www.cnblogs.com/bigox/p/10700567.html