浅尝python 三

二、常见数据类型操作（续）

3、元组操作

用处：主要作为函数的参数和返回值，在自动化里，数据需要组成元组
元组和数组最直观的区别：元组中的数据不能修改【这里不可修改指元组中元素的地址，eg：元组元素的一个值为列表，这个列表的内容是可以修改的】，列表中数据可以修改；所以元组只有查询操作

3.1、元组 tuple类型

表现形式为（）,和列表一样，可以存储多个数据，可以存储任意类型的数据
元组 定义方式：

• 空元组定义

myTuple = tuple()
print(myTuple)
输出结果为：
()

• 直接使用【定义&初始化元组】

myTuple=('zhangsan','18',1.75)
print(myTuple)
输出结果为：
('zhangsan', '18', 1.75)

3.1.1 、类型转换：字符串转换为元组

myTuple=tuple('hello')
print(myTuple)
输出：
('h', 'e', 'l', 'l', 'o')

3.1.2、类型转换：将列表转换为元组

即 将列表的中括号 变为小括号

myTuple2=tuple([1,2,3,5])
print(myTuple2)
输出：
(1, 2, 3, 5)

ps:有种特殊情况，定义一个数据的元组，数据后边必须加上逗号

my_tuple=(5,)
print(my_tuple)
输出：
(5,)

3.2、元组的查询

元组只有查询的方法，查询支持5种形式：

3.2.1、通过下标获取单个数据

myTuple2=tuple([1,2,3,5])
print(myTuple2[2])  
输出 3

3.2.2、切片获取多个数据

myTuple2 = tuple([1, 2, 3, 5])
print(myTuple2[::])
print(myTuple2[::3])
输出：
(1, 2, 3, 5)
(1, 5)

3.2.3、len（）求长度

my_tuple = (5,2)
print(my_tuple)
print(len(my_tuple))
输出：
(5, 2)
2

3.2.4、count（）统计某个数据个数

my_tuple = (5,2)
print(my_tuple)
print(my_tuple.count(2))
输出：
(5, 2)
1

3.2.5、遍历

myTuple2 = tuple([1, 2, 3, 5])
for i in myTuple2:
    print(i)
输出：
1
2
3
5

3.3、交换2个变量的值

在定义元组的时候，小括号可以省略

myTuple = 1,2
print(myTuple)
输出：
(1, 2)

3.3.1 、组包，拆包

组包（pack）：将多个数据值，变成元组存储的过程
拆包（unpack）：将容器中数据分别给到多个变量的过程，保证容器中数据个数=被赋值的变量个数

a = 10
b = 20

• step1: 定义元组

myTuple = (a, b)

组包：

myTuple2 = a, b # 此操作为组包
print(f'myTuple={myTuple},myTuple2={myTuple2}')

输出：

扫描二维码关注公众号，回复： 16875094 查看本文章

myTuple=(10, 20),myTuple2=(10, 20)

b, a = myTuple2  # 此操作为拆包
print(a, b)

输出：
20 10

综上，拆包组包组合，可以直接写为：

a = 10
b = 20
print(a, b)
a, b = b, a
print(a, b)
输出为：
10 20
20 10

元组的特殊用法：交换两个变量的值
在python中可以使用对应数据个数的变量，获取对应元组数据中的每个元素
在python中定义多个元素的元组数据时，小括号可以省略
借助以上两个特性，可以通过元组快速交换两个变量的值

4、字典操作

字典类型： dict ，由键值对组成，表现为 {键：值，键：值}
键值对间用逗号隔开，一个键值对表示一个数据

字典的键一般为字符串，可以是数字，字典的值可以是任意类型
在字典中，键是不能重复的，字典中没有下标

4.1、定义字典

• 空字典

myDict1 = dict()
myDict2 = {
    
    }
print(myDict1, myDict2, type(myDict1), type(myDict2))
{
    
    } {
    
    } <class 'dict'> <class 'dict'>

• 非空字典

# 小强，27，1.81，爱好：射箭，爬山，夜骑,看书
myDict = {
    
    'name': '小强', 'age': 27, 'height': '181cm', 'hobby': ['射箭', '爬山', '夜骑', '看书']}
print(myDict)
输出：
{
    
    'name': '小强', 'age': 27, 'height': '181cm', 'hobby': ['射箭', '爬山', '夜骑', '看书']}

a = myDict.get('hobby')
print(a, type(a), len(myDict))
输出：
['射箭', '爬山', '夜骑', '看书'] <class 'list'> 4

4.2、字典的添加和修改

• 字典中没有下标，通过键（key）去修改数据

ps: 字典 {‘键’} = 数据值，如果键已经存在，就是修改，如果不存在就是添加数据

myDict2 = {
    
    'name': '小强', 'age': 18,'hobby':['a',33]}
print(myDict2)
myDict2['age'] = 20  # 修改
myDict2['weight'] = 90 # 添加
myDict2['hobby'].append('study') # 添加
print(myDict2)
输出：
{
    
    'name': '小强', 'age': 18, 'hobby': ['a', 33]}
{
    
    'name': '小强', 'age': 20, 'hobby': ['a', 33, 'study'], 'weight': 90}

4.3、字典的删除

myDict2 = {
    
    'name': '小强', 'age': 18, 'hobby': ['a', 33]}
print(myDict2)
myDict2.pop('name')
myDict2['hobby'].pop(1)
print(myDict2)
输出：
{
    
    'name': '小强', 'age': 18, 'hobby': ['a', 33]}
{
    
    'age': 18, 'hobby': ['a']}

4.4、字典查询

4.4.1、字典查询2种方式

字典查询2种方式 ：
1、字典[‘键‘] ，如果值存在就返回对应的值，如果要获取的数据不存在 ，程序会直接报错
2、字典.get(‘键’) ，若数据存在，则返回对应的值。若不存在则返回None

myDict2 = {
    
    'name': '小强', 'age': 18, 'hobby': ['射箭',  '夜骑']}
print(myDict2['age'])
print(myDict2.get('age'))
输出：
18
18
print(myDict2.get('cc'))  # 不存在返回None
print(myDict2.get('hobby')[0])
输出：
None
射箭

print(myDict2['cc'])
输出报错：
Traceback (most recent call last):
File "/xx/sourceCode/xx/xx.py", line 5, in <module>
    print(myDict2['cc'])
KeyError: 'cc'

4.4.2、字典遍历

将容器中数据逐个取出
字典是由键值对组成的，字典的遍历分为3种

4.4.2.1、遍历字典的键

实现形式：
for key in 字典： # key为字典的键
pass
for key in 字典.keys（）： # 获取字典中所有key值
pass

myDict = {
    
    'name': '小强', 'age': 27, 'hobby': ['射箭', '爬山', '夜骑', '看书']}

for key in myDict:
    print(key)
print('---------')
for key in myDict.keys():
    print(key)

print(myDict.keys()) # 输出为元组
print(list(myDict.keys())) # 输出为列表

输出：
name
age
hobby
---------
name
age
hobby
dict_keys(['name', 'age', 'hobby'])
['name', 'age', 'hobby']

4.4.2.2、遍历字典值

实现形式：
for 变量 in 字典.values（）
获取字典所有的值：字典.values（）
可以使用list类型转换，也可以转换为tuple（）元组

myDict = {
    
    'name': '小强', 'age': 27, 'hobby': ['射箭', '爬山', '夜骑', '看书']}

for v in myDict.values():
    print(v)
print('遍历 myDict.values()完毕')
for k in myDict:
    print(myDict.get(k))
print('遍历 myDict ，myDict.get(k) 完毕')

print(f'myDict.values={tuple(myDict.values())}')
print(f'tuple(myDict.values())={tuple(myDict.values())}')  # 可以转成元组
print(f'list(myDict.values())={list(myDict.values())}')  # 可以转换为列表

输出：

小强
27
['射箭', '爬山', '夜骑', '看书']
遍历 myDict.values()完毕
小强
27
['射箭', '爬山', '夜骑', '看书']
遍历 myDict ，myDict.get(k) 完毕
myDict.values=('小强', 27, ['射箭', '爬山', '夜骑', '看书'])
tuple(myDict.values())=('小强', 27, ['射箭', '爬山', '夜骑', '看书'])
list(myDict.values())=['小强', 27, ['射箭', '爬山', '夜骑', '看书']]

4.4.2.3、遍历字典的键和值

实现形式：
字典.items（） 可以获取字典中所有的键值对，每个键值对组成元组
for key，value in 字典.items（）：
pass

myDict = {
    
    'name': '小强', 'age': 27, 'hobby': ['射箭', '爬山', '夜骑', '看书']}
for key, values in myDict.items():
    print(key, values)
输出：

name 小强
age 27
hobby ['射箭', '爬山', '夜骑', '看书']

4.4.2.4、demo

data = [
    {
    
    'desc': '登陆失败，用户名为空', 'username': '', 'password': '123123', 'verify_code': '8888',
     'expect': '用户名不能为空'},
    {
    
    'desc': '登陆失败，密码错误', 'username': 'name', 'password': '123123', 'verify_code': '8888',
     'expect': '密码错误'},
    {
    
    'desc': '登陆失败，验证码有误', 'username': 'name', 'password': '123123', 'verify_code': '8888',
     'expect': '验证码有误'}
]
按照如下格式打印输出
# 用户名：xx 密码：xx 验证码：xx 期望结果：xx
for d in data:
    print(f'用户名：{d.get("username")} 密码：{d.get("password")} 验证码：{d.get("verify_code")} 期望结果：{d.get("expect")}')

输出：
用户名： 密码：123123 验证码：8888 期望结果：用户名不能为空
用户名：name 密码：123123 验证码：8888 期望结果：密码错误
用户名：name 密码：123123 验证码：8888 期望结果：验证码有误

将测试数据组成[(),()]

data = [
    {
    
    'desc': '登陆失败，用户名为空', 'username': '', 'password': '123123', 'verify_code': '8888',
     'expect': '用户名不能为空'},
    {
    
    'desc': '登陆失败，密码错误', 'username': 'name', 'password': '123123', 'verify_code': '8888',
     'expect': '密码错误'},
    {
    
    'desc': '登陆失败，验证码有误', 'username': 'name', 'password': '123123', 'verify_code': '8888',
     'expect': '验证码有误'}
]
newlist=[]
for d in data:
    print(tuple(d.values()))
    print(f'd.values()={d.values()}')
    print(f'list(d.values())={list(d.values())}')
    d.pop('desc')
    newlist.append(tuple(d.values()))
print(newlist)
输出：
('登陆失败，用户名为空', '', '123123', '8888', '用户名不能为空')
d.values()=dict_values(['登陆失败，用户名为空', '', '123123', '8888', '用户名不能为空'])
list(d.values())=['登陆失败，用户名为空', '', '123123', '8888', '用户名不能为空']
('登陆失败，密码错误', 'name', '123123', '8888', '密码错误')
d.values()=dict_values(['登陆失败，密码错误', 'name', '123123', '8888', '密码错误'])
list(d.values())=['登陆失败，密码错误', 'name', '123123', '8888', '密码错误']
('登陆失败，验证码有误', 'name', '123123', '8888', '验证码有误')
d.values()=dict_values(['登陆失败，验证码有误', 'name', '123123', '8888', '验证码有误'])
list(d.values())=['登陆失败，验证码有误', 'name', '123123', '8888', '验证码有误']
[('', '123123', '8888', '用户名不能为空'), ('name', '123123', '8888', '密码错误'), ('name', '123123', '8888', '验证码有误')]

三、函数基础语法

1 、函数基本使用

函数的作用：对代码进行封装，提高编程效率，减少代码荣誉，减少冗余代码

现有的很多函数：
print()控制台打印输出
input()获取键盘的输入
type（）获取变量的类型
len（）容器的长度

我们也可以自己定义函数，实现特定功能：

1.1、函数的定义：

def 函数名（）
pass

• demo1

def tpshop_login():
    print("1 输入用户名")
    print("2 输入密码")
    print("3 输入验证码")
    print("4 点击登陆")

tpshop_login()
输出：
1 输入用户名
2 输入密码
3 输入验证码
4 点击登陆

1.2、带参数的函数

• demo2

def say_hi(i):
    """多次打招呼"""  # 函数注释，3对双引号
    n = 0 
    while n < i:
        n += 1
        print(f'hi {n}')

say_hi(int(3))
输出：
hi 1
hi 2
hi 3

• demo3

def sumData(a, b):  # a,b 形参
    print(a + b)

sumData(10, 200)
输出：
210

1.3、函数的嵌套调用

def func1():
    print(1)
    print('func 1')
    print(2)
def func2():
    print(3)
    func1()
    print(4)

print(5)
func2();
print(6)
输出：
5
3
1
func 1
2
4
6

1.4、函数带返回值

return 只能用在函数中，结束函数的运行和返回结果到调用的地方

def sumData(a, b):
    return a + b
print(sumData(10, 1))
输出：
11

其他练习：
# 案例

# 1 定义名为 input_name 的函数，获取用户输入的用户名
def input_name():
    return input("输入的用户名")
# 2 定义名为 input_pwd 的函数，获取用户输入的密码
def input_pwd():
    return input("输入的密码")

# 3 定义名为 login 的函数，判断获取的用户名和密码信息
def login():
    if input_pwd() == '123123' and input_name() == 'admin':
        print('登陆成功')
    else:
        print('用户名或密码错误')

# 4 要求当获取的用户名为 admin且密码123123，输出登陆成功，否则提示用户名或密码错误
login()
输出：
输入的密码123123
输入的用户名admin
登陆成功

2、模块和包

2.1、模块导入 两种方式

方式1: import 模块名 ，eg：

import random
print(random.randint(1, 10))

方式2: from 模块名 import 工具名 ，eg：

from random import randint
print(randint(1, 10))

• demo：
  依赖工具类： tools.py
  1、定义一个模块tools.py,在模块中定义函数 sumData（）,可以对两个数字求和
  2、 新定义一个代码文件，调用tools.py 文件中的sumData函数，对10和20求和

import test.tools

print(f'import test.tools： {test.tools.sumData(10, 20)}')
import test.tools as aa

print(f'import test.tools as aa：={aa.sumData(10, 20)}')

from  test.tools import sumData

print(f'test.tools import sumData：{sumData(3,4)}')

from  test.tools import sumData as cc
print(f'test.tools import sumData as cc：{cc(3,4)}')

from  test.tools import sumManyData as cc
print(f'test.tools import sumManyData as cc：{cc(3,4,5)}')

输出：
import test.tools： 30
import test.tools as aa：=30
test.tools import sumData：7
test.tools import sumData as cc：7
test.tools import sumManyData as cc：12

# 1、定义一个函数，make_data,在列表中随机创建10个 1-100之间的数字
# 2、定义一个函数 myMaxData，返回列表中最大的数字
from test.tools import myMaxData1, myMaxData2, myMaxData3, make_data

lista = [1, 4, 8, 100]
print(f'asdf={myMaxData1(lista)}')
print(f'asdf={myMaxData2(lista)}')
print(f'asdf={myMaxData3(lista)}')
print(f'asdf={make_data()}')
输出：
asdf=100
asdf=100
asdf=100
asdf=66

3、定义一个函数sumTest接收一个参数n，在函数中计算1+2+3+...n 的值，并输出结果
from test.tools import sumTest
print(sumTest(3))
输出：
6

4、有如下列表:
my_list = [{
    
    'id': 1,'money': 10}, {
    
    'id': 2, 'money': 20}, {
    
    'id': 3, 'money': 30}, {
    
    'id': 4, 'money': 40}]
要求: 定义一个函数 func, 功能如下
    1. 如果字典中 ID 的值为奇数,则对 money 的值加 20
    2. 如果字典中 ID 的值为偶数, 则对 money 的值加 10
    3. 打印输出列表,查看最终的结果
from test.tools import func

my_list = [{
    
    'id': 1, 'money': 10}, {
    
    'id': 2, 'money': 20}, {
    
    'id': 3, 'money': 30}, {
    
    'id': 4, 'money': 40}]
print(func(my_list))
# 输出：[{'id': 1, 'money': 30}, {'id': 2, 'money': 30}, {'id': 3, 'money': 50}, {'id': 4, 'money': 50}]

from test.tools import inputStr
inputStr()  # 123ass133]
# 请输入一个字符串1234ass1332
# {'1': 2, '2': 2, '3': 3, '4': 1, 'a': 1, 's': 2}
from test.tools import sumParam
from random import randint
a=randint(1,99)
print(a)
sumParam(a)
输出：
90
91 过...
92
93
94
95
96
97 过...
98 过...

# range的使用
# range(n)生成0-n的整数序列
# 1 生成1-20之间的数字列表
print(range(1,21))
mylist=list(range(1,21))
print(mylist)
输出：
range(1, 21)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]


# range（start，end，step）生成[start,end)之间的整数序列，数字间隔为 step ，步长step ，默认是1，可以不写
for i in range(1,10,3):# [1,4,7]
    print(i)
# 生成1-20之间所有的偶数列表
mylist=list(range(2,21,2))
print(mylist)
输出：
1
4
7
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

工具类 定义 tools.py

import random


def sumData(a, b):
    return a + b


def sumManyData(a, b, c):
    return a + b + c


def make_data():
    return random.randint(1, 100)


def myMaxData1(lista):
    maxData = lista[0]
    for a in lista:
        if (maxData < a):
            maxData = a
    return maxData


def myMaxData2(lista):
    a = list(lista)
    a.reverse()
    return a[0]


def myMaxData3(lista):
    a = list(lista)
    return max(a)


def sumTest(n):
    sumData = n

    while n > 0:
        n -= 1
        sumData += n
    return sumData


# 4、my_list = [{'id': 1,'money': 10}, {'id': 2, 'money': 20}, {'id': 3, 'money': 30}, {'id': 4, 'money': 40}]
# 要求: 定义一个函数 func, 功能如下
#     1. 如果字典中 ID 的值为奇数,则对 money 的值加 20
#     2. 如果字典中 ID 的值为偶数, 则对 money 的值加 10
#     3. 打印输出列表,查看最终的结果
def func(my_list):
    list1 = list(my_list)
    for e in list1:
        inte = int(e.get('id'))
        if inte % 2 == 0:
            e['money'] += 10
        else:
            e['money'] += 20
    return list1


# 5 、定义一个函数, 作用: 打印每个字符出现的次数.
# 要求:
# 1.在函数内部提示输入一个字符串
# 2.输出每个字符出现的次数
# 3.相同的字符，只打印一次
#
# 举例: aabcda
# a: 3, b: 1, c: 1, d: 1

def inputStr():
    myDict = {
    
    }
    str = input('请输入一个字符串')
    for i in str:
        intCnt = str.count(i)
        myDict[i] = intCnt
    print(myDict)


# 6、设计过 7 游戏, 定义一个函数func, 要求如下
# 1. 该函数接收一个参数,为一个 1-99 之间的数字
# 2. 函数 对 该数字 到 99 之间的所有数字进行判断, 如果数字 包含 7 或者是 7 的倍数,则输出"过...", 否则输出 具体的数字.
def sumParam(n):
    i = int(n)
    while i < 99:
        # if i % 7 == 0 or str(i).count('7')>0:
        # if i % 7 == 0 or '7' in str(i):
        if i % 7 == 0 or str(i).find('7')!= -1:
            print(f'{i} 过...')
        else:
            print(i)
        i += 1

Python代码文件就是模块

2.2、模块导入顺序

导入模块的时候
1 会先在当前目录中查找，如果找到，就直接使用
2 如果没有找到，会去python的系统目录中查找，如果找到就直接使用
3 如果没有找到，就报错，找不到该模块
应用：自定义的代码文件名字，不要和你要导入的系统模块文件名字一样

2.3、__name__变量的使用

每个代码文件中都有 这个变量：name ，是python解释器自动维护的变量

SumCal.py文件内容：

import name__ as aa
print(aa.sumData(10, 30))

输出结果：
40

name__.py 文件内容：

def sumData(a, b):
    return a + b

# 局部变量test
def func1():
    # 定义局部变量
    num=10
    print(num)

# 如果在本类直接执行程序，__name__的值为'__main__'
# 如果是其他类引入此包名，即__name__的值为 'name_'
# 1 _name_ 变量，每个代码文件中都有，是Python解释器自动维护的变量
# 可以在开发后，测试验证的内容写在这里调试执行
if __name__=='__main__':
    print(sumData(1, 2))
    print(__name__)
    func1()

2.4、包的使用

作用:python文件过多时方便管理
特点：包里有个代码文件 init.py
包得命名需遵循标识符规则

demo1
1 新建一个msgpkg 的包
2 目录下新建两个文件sendmsg和recievemsg
3 在sendmsg文件中定义一个send函数
4 在recieve文件中定义一个recieve函数
5 在外部定义一个msg文件，编写测试代码调用收发消息的函数

2.4.1、导入方式有3种

模块：recieveMessage.py

def recieveMsg():
    print("recieveMsg")

模块：sendMessage.py

def sendMsg():
    print("send msg")

1）、方式1 ： import 包名.模块名

调用工具的模块

import msgpkg.recieveMessage
import msgpkg.sendMessage as sendmsg

sendmsg.sendMsg()
msgpkg.recieveMessage.recieveMsg()

输出：
send msg
recieveMsg

2）、方式2: from 包名 import 模块名
调用工具的模块

from msgpkg import sendMessage, recieveMessage

sendMessage.sendMsg()
recieveMessage.recieveMsg()

输出：
send msg
recieveMsg

3）、方式3: from 包名.模块名 import 工具名
调用工具的模块

from msgpkg.recieveMessage import recieveMsg
from msgpkg.sendMessage import sendMsg

recieveMsg()
sendMsg()

输出：
recieveMsg
send msg

demo2
1 模拟登陆，定义一个函数能接收用户输入的用户名，密码，验证码，根据不同的测试数据返回不同的验证码结果
2 已知正确登陆信息admin/123123 验证码：6666
3 需求1 创建loginservice.py 模块开发登陆功能代码，并存放到service包中
4 要求2 创建useLogin.py 模块开发登陆功能代码，并存放到service包中
5 要求3:至少测试3种测试场景
loginpkg.logservice 的定义

def login(userName,pwd,code):
    if code == '8888':
        if userName=='admin' and pwd==123123:
            return '登陆成功'
        else:
            return '登陆信息有误'

    else:
        return '验证码错误'

调用工具的模块

from loginpkg.logservice import login

print(login('admin1', 123123, '8888'))
print(login('admin', 123124, '8888'))
print(login('admin', 123123, '8887'))
print(login('admin', 123123, '8888'))

输出：
登陆信息有误
登陆信息有误
验证码错误
登陆成功