linux系统中python中的元组 || python中的字典 || python中的函数

一.元组

1. 元组数据类型

>>> li = [1, 2, 3]
>>> t = (1, 2, 3, 'hello', [1, 2, 3], (1, 2, 3)) 
 #元组数据类型
>>> print(type(li), type(t))
<class 'list'> <class 'tuple'>

2.元组数据类型特性

元组数据类型特性：支持：索引，重复， 连接， 成员操作符， for循环,枚举
allow_users = ('user1', 'user2', 'user3')

print(allow_users[0])       #索引
print(allow_users*2)        #重复
print(allow_users + ('user4','user5'))    #连接
print('user1' in allow_users)             #成员操作符

#for循环
for user in allow_users:
    print("allow_users:%s" %(user))

#枚举
for index, item in enumerate(allow_users):
    print(index+1, item)

3. 元组应用

1.元组应用:
x = 1
y = 2
x, y = y, x
print(x,y)
2.元组应用：
t = ("python", "c")

print("hello %s, hello %s" %("python", "c"))
print("hello %s, hello %s" %(t[0], t[1]))
print("hello %s, hello %s" %t)

4.元组的赋值:解压赋值给多个变量

t = ('小明', 20, 120)
name, age, weight = t
print(name, age, weight)

示例：

#求平均成绩：去掉最小值和最大值，求平均成绩。
scores = [100, 89, 90, 89, 67, 109]
# 列表的排序
scores.sort()
# python2中*middle是不能使用的;
min_score（最小值）, *middle（中间的数）, max_score = scores（最大值）

print(*middle)
print(type(middle))
print("最终成绩为:%s" %(sum(middle)/4))

二.字典

1. 创建字典

方法一：
d = {}
print(d, type(d))

# python: hash,
# key-value: 键值对
方法二：
d = {
    'root':[1,2,3,4,5],
    'westos':[23,45,578]
     }

print(d, type(d))
方法三：
d = dict(root='westos', kiosk='redhat')
print(d, type(d))

示例：生成100个用户和原始密码

users = []
for i in range(100):
    # users里面的每个元素作为key值， 所有的value值都为’000000‘
    users.append('user%d' %(i+1))

import  pprint
pprint.pprint({}.fromkeys(users, '000000'))

2.字典支持的特性

1.在字典里面不支持索引， 切片, 连接, 重复;
key值是唯一的；所以key值是不能重复的；
print(d['a'])             #会报错
print(d + {'e':2})        #会报错

2.for循环, 默认循环显示字典的key值;
d = dict(a=1,b=2)
for i in d:
    print(i)
3.遍历字典的key-value值;
for key in d:
    # key, value=d[key]
    print("%s -> %s" %(key, d[key]))
4.成员操作符: 默认查看的是key是否为字典的成员;
print('a' in d)     #a在d字典里吗？
print(0  in d)      #0在d字典里面吗？

3. 字典的增加

1.增加单个元素：
d = dict(a=1, b=2)
#    1. 增加一个元素;
#   1). 如果key值存在， 则更新对应的value值;
#   2). 如果key值不存在， 则添加对应的key-value值

# 如果key值不存在， 则增加key-value值;
d['e'] = 10
print(d)

# 如果key值存在, 则覆盖原有的value值;
d['a'] = 100
print(d)

2.正加多个key-value值：
   1). 如果key值存在， 则更新对应的value值;
   2). 如果key值不存在， 则添加对应的key-value值
d = dict(a=1, b=2)
d2 = {'c':10, 'a':200}
d.update(d2)
print(d)

3.setdefault添加key值;
  1). 如果key值存在， 则不做修改;
  2). 如果key值不存在， 则添加对应的key-value值
d = dict(a=1, b=2)
d.setdefault('f',100)
d.setdefault('a',300)
print(d)

4. 字典的查看

d = dict(a=1, b=2)

print(d['a'])         #通过key值查看value值
print(d.get('1'))     #通过key值查看value值

print(d.values())     #查看所有value值
print(d.keys())       #查看所有key值
print(d.items())      #查看所有key-value值

1.for循环遍历字典：
# 遍历key-value值的方式
d = dict(a=1, b=2)

# 将字典变成[(), ()]形式依次遍历key,value值
for key,value in d.items():
    print(key, '->', value)

2.成员操作符：
#查看key值是否存在?
print('a' in d)

5. 字典删除

(1).通过key值删除:

1.  通过key值删除；
services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
del services['http']
print(services)

(2).pop删除指定key的key-value对

(2).pop删除指定key的key-value对 

   1). 如果key存在, 删除， 并且返回删除key对应的value值;
   2). 如果key不存在, 直接报错
services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
item = services.pop('http')
print("删除http对应的value值:%s" %(item))
print(services)

(3).popitem删除最后一个key-value值

(3).popitem删除最后一个key-value值 

services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
del_key_value_pair = services.popitem()
print(services)
print("删除的key-value对为:", del_key_value_pair)

(4).清空字典内容

(4).清空字典内容 

services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
services.clear()
print(services)

示例1：

重复的单词: 此处认为单词之间以空格为分隔符， 并且不包含，和.；
     1. 用户输入一句英文句子；
     2. 打印出每个单词及其重复的次数;
import pprint      #导入模块
s = input("输入英文句子：")
words_list = s.split()     #以空格将英文句子进行分离存进列表
words_count_dict = {}      #建立空字典
for word in  words_list:   #循环列表
    if word in words_count_dict:
        words_count_dict[word] += 1
    else:
        words_count_dict[word] = 1
pprint.pprint(words_count_dict)

示例2：

 IP重复统计:
    1). 随机生成200个IP;
    2). IP的范围172.25.254.1～172.25.254.200之间
    3). 升序输出输出所有不同的IP及其每个IP重复的次数;
import random
import pprint
# 1. 随机生成200个IP;
n = 200
ip_list = []
for num in range(n):
    # 2).IP的范围172.25.254.1～172.25.254.200之间
    ip = '172.25.254.' + str(random.randint(1,200))
    ip_list.append(ip)
# 3). 所有不同的数字及其每个数字重复的次数
ip_count_dict = {}
for ip in ip_list:
    if ip in ip_count_dict:
        ip_count_dict[ip] += 1
    else:
        ip_count_dict[ip] = 1
pprint.pprint(ip_count_dict)

示例3：

字典的运算：
num1 = int(input())
choice = input()
num2 = int(input())

d = {
    '+': num1 + num2,
    '-': num1 - num2,
    '*': num1 * num2,
    '/': num1 / num2,
}
if choice == '+':
    print(num1+num2)
elif choice == '-':
    print( num1 - num2)
elif choice == '*':
    print(num1 * num2)
elif choice == '/':
    print(num1 / num2)
else:
    print('error choice')

示例4：

用户登陆系统：
userinfo = {'root':'root'}
while True:
    info = """
                 用户管理系统
    1）.注册新用户
    2）.用户登陆
    3）.注销用户
    4）.显示用户信息
    5）.退出系统（exit（0））
请输入你的选择："""
    choice = input(info)
    if choice == '1':
        print("注册新用户".center(50,'*'))
        name = input("注册的用户名：")
        if name in userinfo:
            print("%s用户已注册" %(name))
        else:
            passwd = input("密码：")
            userinfo[name] = passwd
            print("%s用户注册成功！" %(name))
    elif choice == '2':
        print("用户登陆".center(50,'*'))
        for trycount in range(3):
            name = input("用户名：")
            passwd = input("密码：")
            if name in userinfo:
                if userinfo[name] == passwd:
                    print("登陆成功")
                    break
                else:
                    print("用户名或密码错误！")
            else:
                print("%s用户不存在" %(name))
        else:
            print("登陆超过三次机会!")
    elif choice == '3':
        print("注销用户！".center(50,'*'))
        name = input("注销用户名：")
        if name in userinfo:
            # passwd = input("密码：")
            print("%s用户已注销" %(name))
        else:
            print("%s用户名不存在" %(name))
    elif choice == '4':
        print("用户信息".center(50,'*'))
        for key in userinfo:
            print("%s %s" %(key,userinfo[key]) )
    elif choice == '5':
        print("bye!")
        exit(0)
    else:
        print("error:错误的选择！")
        break

6.列表去重

l = ['a', 'b', 'a']


print(list(set(l)))

print({}.fromkeys(l).keys())

二.函数

1.函数理解

1.定义函数： 不执行函数内容
def 函数名(形参):
    函数体
    return 返回值
函数名(实参)
print(函数名(实参))
##定义函数：
def  hello():
    print('hello world')
# 调用函数: 真正执行函数内容
hello()

#定义函数时， 参数称为形参， 这个参数的名字可以任意修改;

2.调用函数：
import pprint
def  hello():
    l = []
    for user in ['harry', 'jerry', 'tom']:
        l.append(user)
    return l
 hello()    #调用函数
pprint.pprint(hello())

2. 带有返回值的函数

1.return 关键字：
def hello():
    # return 关键字， 函数的返回值, 通过print打印;
    # 一般函数都有返回值， 如果在python中没有返回值时， 默认返回None;
    return "world"
print(hello())

2.默认参数
# 默认参数; 如果只传递一个参数， 那么b默认为2；
# 如果传递两个参数， a=2,b=4, 覆盖原有的默认值;
def mypow(a, b=2):
    return a ** b
print(mypow(2,4))
print(mypow(2))

3. 可选参数:
#当形参里面是*变量名, 可选参数， 可以传递任意多个参数；

def Mysum(*args):
    # print(args, type(args))
    return sum(args)

print(Mysum(10,45))
print(Mysum(11,42,43))
print(Mysum(12,456,376,23,12,34))

4.关键字参数:
# 关键字参数，**变量名可以接收任意多个key-value键值对；
# 接收的变量是字典数据类型;
def get_info(name, passwd, **kwargs):
    print(name,passwd, end=' ')
    print(kwargs, type(kwargs))
get_info('xiaoming', 'hello')
get_info('xiaoming', '123', city="xi'an", age=18, weight=100)

示例：

题目需求:
    对于一个十进制的正整数， 定义f(n)为其各位数字的平方和，如:
    f(13) = 1**2 + 3**2 = 10
    f(207) = 2**2 + 0**2 + 7**2 = 53

    下面给出三个正整数k，a, b,你需要计算有多少个正整数n满足a<=n<=b,
    且k*f(n)=n

输入:
    第一行包含3个正整数k，a, b, k>=1,  a,b<=10**18, a<=b;
输出：
    输出对应的答案;

范例:
    输入: 51 5000 10000
    输出: 3

#输入：k  a  b的值
k = int(input("k:"))
a = int(input("a:"))
b = int(input("b:"))


def isok(num):
    if k*f(num) == num:
        return True
    else:
        return False

def f(n):   #计算完全平方和
    res = 0
    for i in str(n):        #强制转化成字符串，依次便利
        res += int(i)**2
    return res
count = 0                      #符合条件的n的个数
for num in range(a, b + 1):    #在a到b之间循环
    # 满足k*f(n) == n
    if isok(num):
        count += 1       #满足条件数量加一
print(count)

3. return关键字

return关键字:
def hello():
    # 函数一旦遇到return， 后面的代码不再执行
    return "ok"
    print("hello")
print(hello())

4.函数的作用域

作用域：
#   局部作用域：
#   全局作用域:
# 局部作用域, 在函数运行时生效， 函数运行结束则释放
# 全局作用域:作用于整个脚本
num = 10
print("out fun: id=", id(num))

def fun():
    # 局部作用域, 在函数运行时生效， 函数运行结束则释放；
    num = 2
    print("in fun: id=", id(num))
    print("in fun: num = %s" %(num))

fun()
print("out fun: num =%s" %(num))

# 声明：
count = 10
print("全局变量：",id(count))

def hello():
    # 函数里面的变量， 只在函数内部生效;
    # global声明局部变量为全局变量;
    global  count
    count = 20
    print("局部变量:", id(count))

hello()
print(count)

示例：

1.Collatz序列
编写一个名为collatz()的函数,它有一个名为number的参数。
如果参数是偶数,那么collatz()就打印出number//2,并返回
该值。如果number是奇数,collatz()就打印并返回3*number+1。
2.然后编写一个程序,让用户输入一个整数,并不断对这个数
调用collatz(),直到函数返回值1
def collatz(number):
    if number%2 == 0:
        print(number//2)
        return (number//2)
    elif number%2 != 0:
        print(3*number+1)
        return (3*number+1)

n = int(input("输入一个数字："))
while True:
    n = collatz(n)
    if n == 1:
        break

执行结果：

5.函数返回多个值

def hello():   #定义函数
    return "hello", "world"     #返回值

result = hello()     #调用函数赋值给一个变量
print(result, type(result))

a, b = ('hello', 'world')
print(a,b)

res1, res2 = hello()   #调用函数赋值给两个变量
print(res1, res2)

示例：

1.定义函数：函数名get_max_min_avg()
2.函数可以传递任意多个数字， 并且保证是整形或者浮点型;
3.如果满足条件， 返回最大值， 最小值，和平均值；
4.如果不满足条件， 返回None;
5.调用函数， 打印函数结果;
def is_int_float(t):  #定义函数，判断是否是整形或浮点型
    for item in t:
        #如果不是整形或者浮点型返回False
        if not isinstance(item,(int,float)):  
            return False
    #否则返回True
    else:
        return True

# 传递任意多个数字, 可变参数：*args , args是元组数据类型。
def get_max_min_avg(*args):  #定义函数
   #调用函数如果是整形或者浮点型
   if is_int_float(args):
       #如果满足要求，返回最大值， 最小值，和平均值    
       return max(args),min(args),sum(args)/len(args)
print(get_max_min_avg(3,5,2,8,6))

6.函数形参的顺序

#形参：
#      args: 是tuple（元组类型）；
#      kwargs: 是dic（字典类型）；
def fun(a, b=2, *args, **kwargs):
    pass
# 常用的参数顺序: 必选参数 > 默认参数 > 可变参数 > 关键字参数
# 特例: 可变参数 > 默认参数
def hello(*args, a=1, b=2):
    print(args)
    print(a,b)

hello(1,2,3,4,5,6,7, a=100, b=200)

7.形参的默认值必须为不可变类型

# 可变数据类型: list, set, dict
# 默认参数的默认值不要是可变数据类型;