欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

python字典,集合,函数

程序员文章站 2024-01-25 18:21:28
...

字典

  • 又称为(# hash,映射,关联数组)
  • “字” —> 先找首字母,查到这个字的解释所在的页数;

字典的定义:

d = {}
d = {“key1”:”value1”}
d = {“key1”:”value1”,”key2”:”value3”}

d = {

"172.25.254.1":
    {
    "user":"root",
    "password":"westos",
    "command":"hostname"
    },

"172.25.254.2":
    {
    "user":"westos",
    "password":"westos1",
    "command":"hostname"
    }

} # 支持异构,嵌套

dict(zip(user,passwd))
“”.fromkeys([“a”,”b”],”1000”)

字典的特性

  • 字典是可变数据类型;可使用len(d)内置函数,计算字典的长度;
  • 字典是无序的,与序列(str,list,tuple)不同的是,不支持索引,切片,连接与重复。只能通过key值获取对应的value值;
  • 字典支持异构,支持嵌套;

字典的增加

d.update()
d.setdefault(key[,value])
- 如果key存在,不更改;如果key不存在,添加key-value到字典中;
- 如果key值有,并不存在d字典中,默认value值为None;

字典的删除

d.pop(key) # 根据某个key值删除字典中的key-value值;
d.popitem() # 随机删除key-value值
d.clear() # 清空字典的所有内容,字典还存在
del(d[“key”]) # 删除指定的key值
del(d) # 删除字典d,d直接不存在

字典的修改

d[“key2”]=”value3”

字典信息的查看

d.get(“key”) # 如果key存在,返回value值;如果不存在,返回None;
d[“key”] # 如果key存在,返回value值;如果不存在,直接报错;
d.has_keys(“key”) # 如果key存在,返回True;如果不存在,返回False;
d.items()
d.keys()
d.values()

注意:如何遍历字典的所有key-value值:

for key,value in d.items():
    print key, value

字典的复制

d.copy()

In [105]: d1 = d.copy()

In [106]: id(d)
Out[106]: 20314528

In [107]: id(d1)
Out[107]: 20338192

In [108]: d2 = d

In [109]: id(d2)
Out[109]: 20314528

集合

集合的定义

** 不可变的数据类型一定可哈希;hash()内置函数可以判断某个类型是否可哈希;

集合的关系测试

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = {1, 2}
s4 = {5}

print "s1,s2,s3的交集:", s1.intersection(s2, s3)
print "s1,s2,s3的交集:", s1 & s2 & s3
print "s1,s2,s3的并集:", s1.union(s2, s3)
print "s1,s2,s3的并集:", s1 | s2 | s3
print "s1-s2的差集:", s1.difference(s2)
print "s1-s2的差集:", s1 - s2
print "s1-s2-s3的差集:", s1.difference(s2, s3)
print "s1-s2-s3的差集:", s1 - s2 - s3
print "s2-s1的差集:", s2.difference(s1)
print "s1和s2的对等差分:", s1.symmetric_difference(s2)
print "s1和s2的对等差分:", s1 ^ s2
print "s2和s1的对等差分:", s2.symmetric_difference(s1)

# s.isdisjoint(s2)  如果有交集,返回False;否则,返回True;
print "s1和s4是否没有交集:", s1.isdisjoint(s4)

print "s3是否为s1的子集:", s3.issubset(s1)

print "s1是否为s3的父集:", s1.issuperset(s3)

集合的增删改查:

  • 增加: s.add(1), s.update(s1)
  • 删除:
    s.remove(1), # 删除存在的元素,如果不存在,直接报错;
    s.discard(1) # 删除存在的元素,如果不存在,do nothing;
    s.pop(), # 随即删除集合元素,不加任何参数;
  • 复制: s1 = s.copy() #s和s1的id不同
  • 清空: s.clear()

冻集(frozenset)

  • 冻住的集合,不能增删改;
  • frozenset(set)
  • set(frozenset)

函数

内置函数(BIF,built-in function)

min,max,sum,zip,abs,
int,float,str,list,tuple,bool,

In [56]: bool(1)
Out[56]: True

In [57]: bool("")
Out[57]: False

函数实质上是一个变量;函数名是一个指向函数对象的引用,完全可以把函数赋值给一个变量,相当于给这个函数起了个别名;

In [59]: a = abs    # a变量指向abs函数

In [60]: a(-1)      # 可以通过a实现abs的功能;
Out[60]: 1

In [61]: abs(-1)
Out[61]: 1

定义与调用函数

def 函数名([形式参数]):
函数体 # 函数要执行的程序
return 返回值 # 如果没有return返回,默认返回值为None;

函数名([实参])

注意:有返回值 的函数,必须print fun(),可以打印出返回值;

函数的返回值

  • 在函数中,一旦遇到return关键字,函数就执行结束;
  • 函数返回值只能返回一个,如果想间接返回多个值,返回值实际是一个元组;
def maxSum(num1,num2,num3):
        print num2
        return max(num1,num2,num3),sum([num1,num2,num3])
        num1 += 2
        print num1


print type(maxSum(1,4,2))
print maxSum(1,4,2)

函数的参数传值

必选参数:形参与实参的个数必须相同,否则直接报错;

默认参数:在定义函数时,给形参一个默认值;

可变参数:传入的参数个数是可变的,可以是1-n个,也可以是0个;一般实参中用*args来表示可变参数;

args接收的是一个元组(tuple);

关键字参数:允许传入0个或多个包含参数名的参数,传进来的参数自动封装为一个字典.

如果四种函数参数同时存在,参数定义的顺序必须是: 必选参数,默认参数,可变参数,关键字参数.

解包:
- 把一个序列元素依次传入带有可变参数的函数时,可通过fun(*l)来解包;
- 把一个字典元素依次传入带有关键字参数的函数时,可通过fun(**d)来解包;

变量的作用域

  • 全局参数:在函数外定义的函数
  • 局部参数:在函数内部定义的函数;
  • global:声明局部变量为全局变量;
global name
name = "westos"

思维导图

python字典,集合,函数

练习

题目1:用户管理系统V2:

用户功能如下:
welcome to xxxx system

  • 1.注册:若用户存在,直接报错”name 已经存在”,若用户不存在,将用户信息保存起来,显示”注册成功”;
  • 2.登陆:若用户存在,判断密码是否正确,若用户不存在,报错”name 不存在”;
  • 3.注销:若用户存在,删除用户信息;若不存在,报错报错”name 不存在;
  • 4.退出:break
#!/usr/bin/env python
#coding:utf-8
d = {"name":"passwd"}
def register():
        user = raw_input("User:")
        if d.has_key(user):
                print"%s 已经存在" %(user)
        else:
                passwd = raw_input("Passwd:")
                d[user] = passwd
                print "%s 注册成功!"
def info():
        print "user\tpasswd"
        for user,passwd in d.items():
                print "%s\t%s\n" %(user,passwd)
def login():
        user = raw_input("login username:")
        passwd = raw_input("login passwd:")
        if d.has_key(user)and d[user] == passwd:
                print"登陆成功"
        else:
                print"%s不存在" %(user)
def delete():
        while 1:
                user = raw_input("which user?:")
                if d.has_key(user):
                        del(d[user])
                else:
                        print"%s不存在" %(user)
                if raw_input("continue?(y/n)")!="y":
                        break
while 1:
        pro="""
                welcome to user login system:
        登陆(l)ogin:
        注册(r)egister:
        注销(d)elete:
        显示(i)nfo:
        退出(e)xit:
        choose:"""
        choose = raw_input(pro)
        if choose == "l":
                login()
        elif choose == "r":
                register()
        elif choose == "d":
                delete()
        elif choose == "i":
                info()
        elif choose == "e":
                exit(1)
        else:
                print"error input !please reinput...\n"
                print "\n\n"

测试

[root@foundation60 daima]# ./login.py 

        welcome to user login system:
    登陆(l)ogin:
    注册(r)egister:
    注销(d)elete:
    显示(i)nfo:
    退出(e)xit:
    choose:l 
login username:root
login passwd:westos
root不存在

        welcome to user login system:
    登陆(l)ogin:
    注册(r)egister:
    注销(d)elete:
    显示(i)nfo:
    退出(e)xit:
    choose:r
User:root
Passwd:westos
%s 注册成功!

        welcome to user login system:
    登陆(l)ogin:
    注册(r)egister:
    注销(d)elete:
    显示(i)nfo:
    退出(e)xit:
    choose:l
login username:root
login passwd:westos
登陆成功

        welcome to user login system:
    登陆(l)ogin:
    注册(r)egister:
    注销(d)elete:
    显示(i)nfo:
    退出(e)xit:
    choose:i
user    passwd
root    westos

name    passwd


        welcome to user login system:
    登陆(l)ogin:
    注册(r)egister:
    注销(d)elete:
    显示(i)nfo:
    退出(e)xit:
    choose:d
which user?:root
continue?(y/n)y
which user?:root
root不存在
continue?(y/n)n

        welcome to user login system:
    登陆(l)ogin:
    注册(r)egister:
    注销(d)elete:
    显示(i)nfo:
    退出(e)xit:
    choose:i
user    passwd
name    passwd


        welcome to user login system:
    登陆(l)ogin:
    注册(r)egister:
    注销(d)elete:
    显示(i)nfo:
    退出(e)xit:
    choose:e
相关标签: python