字典、集合、函数

• 字典

  字典是一种可变容器模型，且可存储任意类型对象，

  字典的每个键值对(key=>value)都是用冒号：分割，每个键值对之间用逗号，分割，整个字典包括在花括号{}中，格式如下：

  my_dict = {key1:value1, key2:value2}

  键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

• 

• 值可以取任何数据类型，但键必须是不可变的，如字符串、数字或元组。

  一个简单的字典实例：

• 也可以用下面的方法创建字典：

  dict = {'Alice':'2341', 'Beth':'9102', 'Cecil':3258}

也可以用下面的方法创建字典：

• dict1 = {'abc':456}

• dict2 = {'abc':123, 98.6:37

• 访问字典里的值

• 把相应的键放入熟悉的方括号，如下实例：

 

如果用字典里没有的键访问数据，会输出错误如下：

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例：

 

删除字典元素

能删除单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

清空字典只是晴空字典的所有内容，但字典还存在

del 字典  则是将字典全部删除，包括形式及内容
字典键的特性

字典值可以没有限制地取任何Python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点要记住：

1）不允许同一个键出现两次。创建时如果同一个键被两次赋值，后一个值会被记住，前一个会被覆盖，如下示例：

 

2）键必须不可变，所以可以用数字、字符串或者元组充当，用列表就不可以，如下实例：

 

字典内置的函数&方法

Python字典包含了以下内置函数：

序号	函数及描述
1	cmp(dict1, dict2) 比较两个字典元素
2	len(dict) 计算字典元素个数，即键的总数
3	str(dict) 输出字典可打印的字符串表示
4	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型

 Python字典包含了以下内置方法：

序号    函数及描述
1    

dict.clear()

删除字典内所有元素
2    

dict.copy()

返回一个字典的浅复制
3    

dict.fromkeys(seq[val1,val2])

创建一个新字典，以序列seq中元素作为字典的键，val为字典所有键对应的初始值
4    

dict.get(key, default = None)

返回指定键的值，如果值不在字典中返回default值
5    

dict.has_key(key)

如果键在字典dict中返回true，否则返回false
6    

dict.items()

以列表返回可遍历的（键，值）元组数组
7    

dict.keys()

以列表返回一个字典所有的键
8    

dict.setdefault(key, default=None)

和get()类似，但如果键不存在于字典中，将会添加键并将值设为default
9    

dict.update(dict2)

把字典dict2的键/值对更新到dict里
10    

dict.values()

以列表返回字典中的所有值
11    

pop(key[,default])

删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值
12    

popitem()

随机返回并删除字典中的一对键和值

列表

列表（list）用来存储不同的数据类型，使用 [ ]

例如：

service = ['http','ssh','ftp']

列表的特性：
1.1：索引：

print(service[1])    ##输出第二个元素，ssh
print(service[-1])   ##输出最后一个元素，ftp

1.2：切片：

print(service[1:])   ##打印第一个元素之后的内容
print(service[:-1])  ##打印最后一个元素之前的内容
print(service[::-1])  ##倒序输出

1.3：重复：

print(service * 3)   ##输出三遍

 

1.4：连接：

service1 = ['nfs','samba']
print(service + service1)

1.5：成员操作赋:

print('nfs' in service)   ##判断是否存在

1.6：迭代:[for循环遍历]

for i in service:
	print(i)       ##遍历输出每个元素

1.7列表里嵌套列表

service2 = [['abc','def','www'],[1,2,3],['mike','tony','sun']]

对其索引：print(service2[2][1])   ##第三个元素中的第二个元素
对其切片：print(service2[:][1])   ##第二个元素

列表的增删改查：
1.增加：

往列表里增加元素:

1.print(service + ['firewalld'])   ##用连接的方式

2.service.append('firewalld')   print(service)    ##append:追加一个元素到列表中

3.extend:拉伸 追加多个元素到列表中  service.extend(['mysql','firewalld'])

4.service.insert(1,'samba')  ###在指定索引位置插入元素  ##在第二个元素的位置插入samba作为第二个元素

2.删除：

1.service.pop()   ##弹出最后一个元素
a = service.pop(0)  ##弹出第1个元素  ###可以将其赋值

2.service.remove('ssh') ##指定删除对象的名字  ##直接删除，不能将其赋值   ##不能指定序号，只能指定要删除对象的

3. del service  ##删除列表

del service   ##直接删除整个列表
print(service)

3.赋值：

1.service[0] = 'mysql'   ##通过索引 重新赋值

2.service[:2] = ['samba','iscsi']  ##通过切片给前两个元素重新赋值

4.查看：
查看出现的次数

service.count('ssh')

    1

查看指定元素的索引值

service.index('iscsi')    ###最小索引值
service.index('ssh',1,3)   ###从1-3中查找【第二个元素和第三个元素之间】【不取上限】

   

5.排序：
sort 排序
对字符串排序不区分大小写

names = ['alice','Bob','coco','Harry']
names.sort()
names      ###按照ASCLL排序   ###先排序首字母为大写的，再排序首字母是小写的

names.sort(key=str.lower)   ###对字符串排序不区分大小写，相当于将所有元素转换为小写，再排序
names.sort(key=str.upper)   ###相当于将所有元素转换为大写，再排序

5.排序：
sort 排序
对字符串排序不区分大小写

names = ['alice','Bob','coco','Harry']
names.sort()
names      ###按照ASCLL排序   ###先排序首字母为大写的，再排序首字母是小写的

names.sort(key=str.lower)   ###对字符串排序不区分大小写，相当于将所有元素转换为小写，再排序
names.sort(key=str.upper)   ###相当于将所有元素转换为大写，再排序

  

乱序

li = list(range(10))   ##生成0-9，将其转换为列表形式
print(li)
import random
random.shuffle(li)   ##随机打乱
print(li)    
————————————————
版权声明：本文为CSDN博主「dddxxy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/dddxxy/article/details/94428000

乱序

li = list(range(10))   ##生成0-9，将其转换为列表形式
print(li)
import random
random.shuffle(li)   ##随机打乱
print(li)    

函数

使用关键字def定义函数

python中允许嵌套定义函数，即一个函数定义的内部再定义一个函数
但是，内部定义函数，不仅要有定义，也要有调用（否则就白定义了～～）

 如何定义一个函数
def hello():
    print('python')
    print('hello')

# 通过函数名来调用函数
hello()
hello()

def westos():
    print('it is westos')
    def python():
        print('is python')
    python()    #若没有在westos函数的定义中调用python的话，则不会输出python函数
westos()

# 定义函数的时候使用的变量叫形参(名字任意)
# 形参实际就是一个占位符，等待实参传入具体的值
def welcome(a):
    print('welcome',a)
# 真实的数据信息,调用函数的时候传递进入函数内部值的变量(参数)叫函数的实参
welcome('tom')
welcome('lily')
# welcome()

函数的形参

函数参数: 实参 形参
形参:位置参数 默认参数 可变参数 关键字参数

实际参数若没有对应的形式参数来接收（对应），会报错

# 位置参数:形参和实参必须保持一致
# 实参 向形参传递值，依靠参数位置来传递/依靠参数名称指明相应的形参传递值
def getinfo(name,age):
    print('姓名:',name,'年龄:',age)
# getinfo('westos',11)
# getinfo(11,'westos')
getinfo(age=11,name='westos')

# 默认参数
默认参数，对于原始的默认函数，进行二次封装
使得自己新定义的函数，即便少输入参数也可以正常执行。
默认参数：
当该形参未接收到数据时，以默认值执行函数。
当该参数接收到值时，以所接收到的实参的值来执行函数
def mypow(x,y=2):
    print(x ** y)
mypow(2,3)
mypow(2)

# 可变参数
输入*num 解包
def mysum(*a):      #*a 该形参接收一串整型或浮点型的值
    print(*a)
    print(a)
    sum  = 0
    for item in a:
        sum += item
    print(sum)

# mysum(1,2,3,4,5)     传入一串整型序列，可以成功调用函数
# mysum([1,2,3,4,5])   直接传入一列表，调用函数失败
nums = [1,2,3,4]
nums2 = (1,2,3,4)
nums3 = {1,2,3,4}
# 参数解包:在参数名前加*
# 却不能直接用列表,元组,集合作为实参,需要先解包(使用*符号)
mysum(*nums) # *nums:1 2 3 4
mysum(*nums2)
mysum(*nums3)

# 关键字参数
def getinfo(name,age,**k):
    print(name)
    print(age)
    print(k)
d = dict(a=1,b=2)
print(*d)
# getinfo('westos',12,**d)

 

 

函数的返回值

想让变量引用函数的结果，必须让函数将其结果作为返回值返回。
否则，函数执行完毕后，其内存地址被释放，其结果值无法被变量引用

与c不同的是，python可以有多个返回值同时返回。因为python帮我们将其封装成了一个元组类型

返回值：函数运算的结果，还需要进一步操作，就给函数的执行结果一个返回值，将其值传出函数
return用来返回函数执行的结果，如果函数没有返回值，默认返回None
一旦遇到return 函数执行结束，后面的代码不会执行
多个返回值的时候，python会帮我们封装成一个元组类型

def mypow(x,y=2):
    #print(x ** y)
    # pass
    return x**y,x+y
a = mypow(2,4)
print(a)
print(mypow(5,2))

 

函数的作用域

可以参考c语言中变量的生命域/作用域

a = 1
print('outside:',id(a))

def fun():
    global a #声明a为全局变量   可以再将关键字global去掉
    a = 5
    print('inside:',id(a))

fun()
print(a)
print(id(a))

#  id() 查看变量所引用的内存地址空间