Python基础编程（2）

元组（tuple）

1、元组与列表的区别

列表是可变的，元组是不可变的。

列表的可变指的是列表可以添加元素，可以删除元素，

元组的不可变指的是元组不可以增加新的元素，也不可以删除已有的元素

2、元组的组成元素

元组里面的元素可以是字符串，也可以是数字， 也可以是元组本身，也可以是列表

3、'count'与'index'

tuple.'count'：查看元组的

tuple.'index'：

4、注意事项

当元组里面只有一个元素时，一定在元素后面加逗号

5、编程实训

1）创建元组

#创建tuple1元组
tuple1=(1,'a',2,1,['Go','Python',(1,2,3,'4')])
#输出在tuple1中元素[1]的数量
print(tuple1.count(1))
#输出在tuple1中元素[2]的索引
print(tuple1.index(2))

#运行结果
2
2

2）获取元组里面的元素

#获取元组里面的元素[Go]
print(tuple1[4][0])
#获取元组里面的元素['4']
print(tuple1[4][2][3])

#运行结果
Go
4

3）元组循环与判断

#在tuple1里，通过enumerate关键字，获取索引与元素
for index,itme in enumerate(tuple1):
	print(index,itme)
#判断是否有元素[Go]，若有，则输出“学习Go语言”
if index==4 and itme[0]=='Go':
	print('学习Go语言')
    
#运行结果
2
2
Go
4
0 1
1 a
2 2
3 1
4 ['Go', 'Python', (1, 2, 3, '4')]
学习Go语言

Process finished with exit code 0

字典（dict）

1、字典特性

1）字典是无序的

2）字典是key-value的形式来存储的

2、字典的关键字是dict

for example:
      dict1={'name':'zhangli','age':'18','city':'xian'}

3、排序规则

1）如果是数字，默认是从小到大

2）如果是字符串，内部处理思路是将字符串转为数字，然后和1的规则相同

3）如果是多个字符串比如aa,ab，那么这个时候它的规则是：  

A、aa和ab先比较第一个字符串，发现第一个相同，就比较第二个  

B、比较第二个，比如是字符串转为数字，规则与1相同

4、字符串转为数字

把字符串转为数字，使用内部函数是ord( )

5、字典排序

排序必须是相同的数据内型,字典排序使用到的内部函数是sorted( )

6、编程实训

1）创建字典

#创建字典
dict1={'name':'zhangli','age':'18','city':'xian'}
print(dict1)

#运行结果
{'name': 'zhangli', 'age': '18', 'city': 'xian'}

2）获取key与valus（字典循环）

#获取key
for itme in dict1.keys():
	print(itme)
#获取valus
for itme in dict1.values():
	print(itme)
#获取所有的key与valus
for key,valus in dict1.items():
	print(key,valus)
    
#运行结果
name
age
city
zhangli
18
xian
name zhangli
age 18
city xian

Process finished with exit code 0

3）获取valus的值

通常使用第二种方法

#获取valus的值
print(dict1.get('age'))
print(dict1['age'])

#运行结果
18
18

4）两个字典合并

#两个字典合并
dict2={'name':'zhangli','age':'18','city':'xian'}
dict3={'valary':'1800'}
dict2.update(dict3)
print(dict2)

#运行结果
{'name': 'zhangli', 'age': '18', 'city': 'xian', 'valary': '1800'}

5）字典排序

#字典排序
dict4={'name': 'zhangli', 'age': '18', 'city': 'xian', 'valary': '1800'}
print(
	dict(
		sorted(dict4.items(),key=lambda item:itme[0])
)
)
print(
	dict(
		sorted(dict4.items(),key=lambda item:item[1])
	)
)

#运行结果
{'name': 'zhangli', 'age': '18', 'city': 'xian', 'valary': '1800'}
{'age': '18', 'valary': '1800', 'city': 'xian', 'name': 'zhangli'}

6）实现字典的有序

#从collections中导入OrderedDict类
from collections import OrderedDict

dict10=OrderedDict()
dict10['name']='zhangli'
dict10['sex']='男'
dict10['school']='一般学校'
print(dict(dict10))

#运行结果
{'name': 'zhangli', 'sex': '男', 'school': '一般学校'}

数据转换

1、字符串与列表的转换

#字符串转换位列表
str1='go,java,python'
str_list=str1.split()
print(str_list)
#列表转换为字符串
list_str=','.join(str_list)
print(list_str)

#运行结果
['go,java,python']
go,java,python

2、列表与元组的转换

#列表转换为元组
list1=['go,java,python']
list_tuple=tuple(list1)
print(list_tuple)
#元组转换为列表
tuple_list=list(list_tuple)
print(tuple_list)

#运行结果
('go,java,python',)
['go,java,python']

3、字符串与整形的转换

#字符串转换为整形
age='18'
salary='1800'
age1=int(age)
salary1=int(salary)
print(type(age1),age1)
print(type(salary1),salary)
#整形转换为字符串
age2=str(age1)
salary2=str(salary1)
print(type(age2),age2)
print(type(salary2),salary2)

#运行结果
<class 'int'> 18
<class 'int'> 1800
<class 'str'> 18
<class 'str'> 1800

4、列表与字典的转换

#列表转换为字典
list2=['a','b','c']
list_dict=dict(enumerate(list2))
print(list_dict)
#字典转换为列表
dict_list=list(list_dict.items())
print(dict_list)

#运行结果
{0: 'a', 1: 'b', 2: 'c'}
[(0, 'a'), (1, 'b'), (2, 'c')]

文件操作

1、文件操作

文件操作又名IO操作，其主要包括读与写两个操作

2、函数的特性

函数特点： 函数有参数    x=f(y)--->y是函数f的参数

3、文件操作三个步骤

1）打开文件（open）

2）操作文件（write）【针对文件的读与写】

3）关闭文件（close）【文件必须关闭，否则会出现内存泄露】

4、open函数参数

1）open函数
     作用：IO操作文件
     参数：
            file：指的是被操作的文件(默认有路径）
            mode：通过什么方式操作文件（读还是写？）
                      a：追加
                      w：写文件内容（替换写入）
                      r：读取文件内容
            encoding：编码（utf-8，gbk）
     写的操作：
           1、不管是否有文件，即使没有文件，open内部会自动创建一个文件，
                然后把写的内容写进去
     读的操作
           1、文件存在，那么从文件中读取数据
           2、文件不存在，会报【FileNotFoundError】的错误信息
                如： [Errno 2] No such file or directory: 'acd.docx'
     with上下文：with open() as f:
           他内部可以对文件进行关闭，这样避免了操作文件忘记关闭

5、实训编程

1）写：wirte

#在文件中写入“hello Python”
f=open(file='login.txt',mode='w',encoding='utf-8')
f.write('hello Python!')
f.close()

#删除文件原有内容，重新写入“Spark”
f=open(file='login.txt',mode='w',encoding='utf-8')
f.write('Spark')
f.close()

#写入多行内容
f=open(file='login.txt',mode='w',encoding='utf-8')
data='''
hadoop
spark
hive
hbase
flink
kafka
'''
#输出读取内容，并取消空格（strip）
f.writelines(data.strip())
f.close()

2）读：read

#读取文件里面所有内容
f=open(file='login.txt',mode='r',encoding='utf-8')
print(f.read())
f.close()

#读取文件里面第一条内容
f=open(file='login.txt',mode='r',encoding='utf-8')
print(f.readline())
f.close()

#按行读取文件所有内容
f=open(file='login.txt',mode='r',encoding='utf-8')
for item in f.readlines():
#输出读取内容，并取消空格（strip）
	print(item.strip())
f.close()
#在非默认路径下读取文件内容
f=open(file='D:/admin.txt',mode='r',encoding='utf-8')
print(f.read())
f.close()

 3）with上下文

格式：with open() as f:

#with上下文
with open(file='D:/admin.txt',mode='r',encoding='utf-8') as f:
	print(f.read())

函数

1、定义

所谓函数，就是把重复的代码单独的分离出来，放在⼀个公共的地⽅，

以后可以⼀直的进⾏调⽤，这样就可以解决多次重复来编写。

2、关键字

函数定义的关键字：def

for example：
    def 函数名称（函数的参数）：
        函数表达式

3、函数调用

函数写完后，必须要经过调用才可以生效，如果不调用，不会生效

调用函数的方式是：函数名称

4、参数分类

1）形式参数：函数里面的参数叫形式参数

2）实际参数：函数被调用的时候，给予参数赋予的值叫实际参数

3）默认参数：在定义函数的时候给形式参数指定了参数的值

4）动态参数：定义一个函数的时候，当函数的形式参数个数不确定，数据类型不确定的时候

5、参数调用注意事项

1）函数在调用的时候，可以填写形式参数，也可以不填写。

2）要么填写，要不都不填写

3）函数在调用的时候，填写的实际参数要与形式参数的顺序、个数保持一致

4）函数有形式参数的时候，调用函数必须填写实际参数

6、动态参数

*：代表的是元组的数据类型

**：代表的是字典的数据类型

7、内部函数

关键字

数字转字母：chr；字母转数字：ord；

包含开始,但不包含结尾：range

8、匿名函数（lambda）

指定一个函数，但是这个函数的名字是可以自定义的 。

for example:
	a=lambda x,y:x+y
    
其中:左边是函数的形式参数
	:右边是函数的表达式

9、过滤函数（filter）

一共三种方式：普通过滤，过滤，匿名过滤

10、迭代增加（map）

针对所有对象做同样的操作

使用前提：1、函数对象 ；2、可迭代的对象

11、函数返回值（return）

一个函数，不管是否有return，它都有返回值的，如果没有return，它的返回值是None

如果有return，函数的返回值是return后面的内容，切记：return后面的代码是不能执行的

函数返回值的价值是：把函数与函数能够建立一层关联关系

12、实训编程

1）定义函数

#定义函数，填写形式参数
def add(a,b):
	print(a+b)
#给予参数赋值（实际参数）
add(3,6)

#定义函数，填写默认参数
def login(username="admin",password="message"):
	print(username+","+password)
#运行函数
login()

#定义函数，填写动态参数
def func(*args,**kwargs):
	print(*args,**kwargs)
func({'name','zhangli'})

#运行结果
9
admin,message
{'name', 'zhangli'}

2）登录账户

#登录账户
def login(username,password):
	if username=='zhangli' and password=='123456':
		print('登录成功')
	else:
		print('登录失败')

login(username='zhangli',password='123456')

#运行结果
登录成功

3）注册账户，并读取至文件

#注册账户
def registry():
	username=input('请输入用户名：\n')
	password=input('请输入密码：\n')
	temp=username+','+password
	with open('login.txt','w') as f:
		f.write(temp)
registry()

#运行结果
1）创建了login.txt文件，且显示zhangli,123456
2）运行结果栏结果：
   请输入用户名：
   zhangli
   请输入密码：
   123456

4）读取内容到文件

写一个函数，将注册的账号读取后，写入login.txt文件里，并单独输出用户名

def registry():
	with open('login.txt','r') as f:
		acd=f.read().split(',')
		print(acd[0])
registry()

def registry():
	with open('login.txt','r') as f:
		for item in f.readlines():
			print(item.split(',')[0])
registry()

#运行结果
zhangli
zhangli

5）动态参数

#输入元组数据
def func(*args):
	print(args)
	print(type(args))

func([1,2,3])
func((1,2))
func({'name','zhangli'})

#输入字典数据
def func(**kwargs):
	print(kwargs)
	print(type(kwargs))

func(name='zhangli',age=18)
func(**{'name':'age'})

#使用场景
def func(*args,**kwargs):
	print(kwargs)

func(payType='alipay',price=100)
func(payType='wxpay')
func(payType='zhaohang',price=100,city='xian')

def func(*args,**kwargs):
	print(kwargs)

func(payType='alipay',price=100)
func(payType='wxpay')
func(payType='zhaohang',price=100,city='xian')

6）内部函数

#数字转字母（chr）
print(chr(98))

#字母转数字（ord）
print(ord('d'))

#包含开始,但不包含结尾（range）
for item in range(1,5):
	print(item)
#导入（import)
import random#内部库，库都是需要导入，导入关键字为import
print(random.randint(1,100))#随机生成数字（5个）

#字符串转为字符串(eval)
str1='5+5'
print(eval(str1))

#运行函数
b

100

1
2
3
4
24

10

 7）验证码生成（随机生成）

list1=[]
#随机循环生成10个数字
for i in range(10):
#在（97，120）之间随机取数，并放入变量r中；前提条件：生成10个数
	r=random.randint(97,120)
#将变量写入列表中，且将数字转换为字母
	list1.append(chr(r))
#将数字转换为字符串，并输出
print(''.join(list1))

#dgawdqxiud

8）匿名函数（lambda）

a=lambda x,y:x*y
print(a(4,5))

#运行结果
20

9）过滤大于2的数字（过滤函数）

#普通方法
list2=[1,2,3,4,5,6,7,8,9]
list3=[]
def func():
	for item in list2:
		if item>2:
			list3.append(item)
	print(list3)

func()

#过滤（filter）
list2=[1,2,3,4,5,6,7,8,9]
def func(a):
	if a>2:
		return True

print(
	list(filter(func,list2))
)


#过滤（filter加lambda）
list2=[1,2,3,4,5,6,7,8,9]
print(
	list(filter(lambda x:x>2,list2))
)

#运行结果
[3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]

10）对各个变量加10

#map迭增方法
list2=[1,2,3,4,5,6,7,8,9]
print(list(map(lambda x:x+10,list2)))

#for循环方法
list4=[]
def func():
	for item in list2:
		list4.append(item+10)
	print(list4)
func()

#运行结果
[11, 12, 13, 14, 15, 16, 17, 18, 19]
[11, 12, 13, 14, 15, 16, 17, 18, 19]

11）登录返回sessionid

#登录返回sessionid
def zhihulogin(username='zhangli',password='admin'):
	if username=='zhangli' and password=='admin':
		return 'we456ertre'
	else:
		return"账户或密码不对"

#判断返回的sessionid参数是否与客户端sessionid一致
def profile(sessionid):
	if sessionid=='we456ertre':
		print("欢迎查看知乎主页")
	else:
		print("请登录！")

#若想登录成功，必须满足账户与密码正确，因此默认参数和实际参数必须为正确的账户与密码
profile(sessionid=zhihulogin())
profile(sessionid=zhihulogin('zhangli','admin'))
profile(sessionid=zhihulogin('zl,admin'))
profile(sessionid=zhihulogin('we456ertre'))

#运行结果
欢迎查看知乎主页
欢迎查看知乎主页
请登录！
请登录！

全局变量与局部变量

1、定义

全局变量：在一个python文件中定义的变量

局部变量：在一个函数中定义的变量

2、优先级

1）在python文件中，调用变量，全局变量优先级是高于局部变量的

2）在函数内部调用变量，局部变量的优先级是高于全局变量的

3）如果在函数内部想引用全局变量，那么使用关键字global

#在python文件中，调用变量，全局变量优先级是高于局部变量的
name='无涯'
def func():
	name='wuya'
print(name)

#在函数内部调用变量，局部变量的优先级是高于全局变量的
name='无涯'
def func():
	name='wuya'
	print(name)
func()

#如果在函数内部想引用全局变量，那么使用关键字global
name='无涯'
def func():
	global name
	print(name)
func()

#运行结果
无涯
wuya
无涯

模块与包

1、在python中，每一个python文件都是一个模块（modyle）

2、包：在一个包里面会很多的模块

3、包与文件夹的区别：包里面有_init_.py文件；文件夹没有

4、一个模块调用另一个模块文件的变量以及函数：form package.module import *（代表所有）

for example:

#调用login.txt，输出login所有内容
from login.f1 import *

print(name)
func()