Python的数据结构—字典和函数

字典的创建

第一种方法
key-value:称为键值对

d = {
    'root':[1,2,3],
    'westos':[4,5,6]
     }

第二种方法

d = dict(root='westos', kiosk='redhat')
print(d, type(d))

第三种方法

import pprint
l = ['user1','user2','user3']
pprint.pprint({}.fromkeys(l,'000'))

字典的特性

字典不支持索引，切片，重复，连接、
再字典内key值是唯一的，所以不支持重复
字典支持for循环和成员操作符
for循环：默认循环显示字典的key值

d = dict(a=1,b=2)
for i in d:
    print(i)

便利字典的键值对：

d = dict(a='1',b='2')
for i in d:
    print("%s->%s" %(i,d[i])

成员操作符：默认查看key是否为字典成员

d = dict(a='1',b='2')
print('a' in d)  #True

字典的增加

增加一个元素

#如果key值存在覆盖原有的value值，
d['a'] = 2
print(d)
#如果key值不存在增加对应的key-value值
d['c'] = 3
print(d)

添加多个key-value值

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

setdefault添加key值

#如果key值存在， 则不做修改;
d = {'c':10, 'a':200,'e':6}
d.setdefault('c',100)
print(d) #{'c': 10, 'a': 200, 'e': 6,}
 #如果key值不存在， 则添加对应的key-value值
 d = {'c':10, 'a':200,'e':6}
d.setdefault('f',100)
print(d) #{'c': 10, 'a': 200, 'e': 6, 'f': 100}

字典的查看

d = {'c':10, 'a':200,'e':6}
print(d['c']) #10
print(d.get('c'))#10
print(d.get('f',1))#1
print(d.get('f'))#None
print(d.keys())#dict_keys(['c', 'a', 'e'])
print(d.values()) #dict_values([10, 200, 6])
print(d.items())#dict_items([('c', 10), ('a', 200), ('e', 6)])

便利key-value值的方法

d = {'c':10, 'a':200,'e':6}
for key,value in d.items():
    print('%s->%s' %(key,value),end=',')
   #c->10,a->200,e->6,

字典的删除

通过key值删除

d = {'c':10, 'a':200,'e':6}
del d['c']
print(d) #{'a': 200, 'e': 6}

通过pop删除指定的key对应的key-value对

#如果key值存在 删除键值对，并返回删除key对应的value值
d = {'c':10, 'a':200,'e':6}
de = d.pop('c')
print(d,de) #{'a': 200, 'e': 6} 10
#如果key值不存在则直接报错

通过popitem删除最后一个key-value值

d = {'c':10, 'a':200,'e':6}
d.popitem()
print(d) #{'c': 10, 'a': 200}

清空字典内容

d = {'c':10, 'a':200,'e':6}
d.clear()
print(d) #{}

字典的练习

重复的单词: 此处认为单词之间以空格为分隔符， 并且不包含，和.；
# 1. 用户输入一句英文句子；
# 2. 打印出每个单词及其重复的次数;

import pprint
l = input("请输入一个句子：")
l1 = l.split()
d = dict()
for item in l1:
    if item in d:
        d[item] += 1
    else:
        d[item] = 1
pprint.pprint(d)

IP重复统计:
1. 随机生成200个IP;
2. IP的范围172.25.254.1～172.25.254.200之间
3. 升序输出输出所有不同的IP及其每个IP重复的次数;

import pprint
import random
ip = dict()
l = []
for i in range(200):
    IP = '172.25.254.' + str(random.randint(1,200))
    l.append(IP)
    l1 = sorted(l)
for item in l1:
    if item in ip:
        ip[item] += 1
    else:
        ip[item] = 1
pprint.pprint(ip)

python 不支持switch和case，可以用字典来实现

num1 = int(input("请输入数字"))
num2 = int(input("请输入数字"))
choice = input("请输入选择")
d = {
    '+': num1 + num2,
    '-': num1 - num2,
    '*': num1 * num2,
    '/': num1 / num2,
}
print(d.get(choice,'error'))

利用字典对列表去重

l = ['a', 'b', 'a']
print({}.fromkeys(l).keys())

用户管理系统

while True:
    menu = """
                用户管理系统
            1，用户注册
            2，用户登陆
            3，注销用户
            4，查看用户信息
            5，退出系统
    请输入你的选择：
    """
    choice = input(menu)
    user_dict = dict(root='westos',westos='redhat')

    if choice == '1':
        username = input("请输入用户名：")
        if username in user_dict:
            print("%s用户已经存在" %(username))
        else:
            passwd = input("请输入密码：")
            user_dict[username] = passwd
            print("注册成功")
    elif choice == '2':
        for trycount in range(3):
            username = input("请输入用户名：")
            if username in user_dict:
                passwd = input("请输入密码：")
                if user_dict[username] == passwd:
                    print("%s用户登陆成功" %(username))
                    break
                else:
                    print("密码错误")
            else:
                print("用户名不存在")
        else:
            print("登陆超过三次")
    elif choice == '3':
        username = input("请输入用户名：")
        if username in user_dict:
            user_dict.pop(username)
        else:
            print("用户不存在")
    elif choice == '4':
        for key,value in user_dict.items():
            print("%s->%s" %(key,value))
    elif  choice == '5':
        break

函数

定义函数

# def 函数名(形参):
#     函数体
#     return 返回值
# 函数名(实参)
# print(函数名(实参))

#定义函数时， 参数称为形参， 这个参数的名字可以任意修改;
#调用函数时的参数称为实参, 这个参数必须有存在的值;
def username(name):
    print("%s hello" %(name))
list = ['user1','user2']
for i in list:
    username(i)

带有返回值的函数

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

形参可以分为必选参数，默认参数，可选参数，关键字参数

默认参数

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

可选参数

当形参里面是*变量名, 可选参数， 可以传递任意多个参数；
def mysum(*args):
    return sum(args)
print(mysum(1,2,3))   # 6
print(mysum(1,2,3,4)) #10

关键字参数

关键字参数，**变量名可以接收任意多个key-value键值对；
接收的变量是字典数据类型
def info(name,passwd,**kwargs):
    print(name,passwd,kwargs)
    print(kwargs,type(kwargs))
info('root','redhat',age=10,weight=80) 
#执行结果:root redhat {'age': 10, 'weight': 80}

接收多个数值的练习
对于一个十进制的正整数， 定义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

k = int(input('k:'))
a = int(input('a:'))
b = int(input('b:'))
def isOk(n):
#是否满足k*f(n) == n， 如果满足， 返回True
    if k*f(n) == n:
        return True
#如果不满足， 返回False；
    else:
        return False
    pass
def f(n):
#计算n的平方和
    sum = 0
    for i in str(n):
        sum += int(i)**2
    return sum
count = 0
for num in range(a,b+1):
# 满足k*f(n) == n
    if isOk(num):
        count += 1
print(count)

return 关键字

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

作用域：分为全局作用域和局部作用域
全局作用域：作用于整个脚本
局部作用域：在函数运行时生效，函数结束时则释放

函数练习

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

def collatz(number):
    if number%2 == 0:
        print(number//2)
        return number//2
    else:
        print(3*number+1)
        return 3*number+1
n = int(input("请输入一个整数："))
while True:
    n = collatz(n)
    if n == 1:
        break