Python 入门

集合

集合：把不同的元素组成一起形成集合，是python基本的数据类型。

集合元素:组成集合的成员。

>>> x = [11,22,33,11]
>>> se = set(x)
>>> se
{33, 11, 22}

集合对象是一组无序排列的不重复的值。

创建集合

字符串，数字，列表和字典都可以作为集合中的元素，当用字典作为集合中的元素时，默认取字典中的Key作为集合中的元素。

 1 >>> x = ()
 2 >>> li = ['a','b','c']
 3 >>> x = (li)
 4 >>> x
 5 ['a', 'b', 'c']
 6 >>> x = set('abcdefg')
 7 >>> x
 8 {'a', 'g', 'c', 'f', 'b', 'd', 'e'}
 9 >>> li = [11,22,33,44,55]
10 >>> y = set(li)
11 >>> y
12 {33, 11, 44, 22, 55}
13 >>> dict = {
14 ...     'cpu':12,
15 ...     'mem':16,
16 ...     'disk':'3.0T',
17 ...     'U位':'15'
18 ... }
19 >>> set(dict)
20 {'disk', 'cpu', 'mem', 'U位'}

 

集合本身是无序的，所以不能为集合创建索引或切片，只能循环遍历或使用in、not in来访问或判断集合元素

s.add()

s.update()

s.remove()

s.clear()

s1.intersection(s2)   s1和s2的交集

>>> s1 = {11,22,33}
>>> s2 = {22,33,44}
>>> s1.intersection(s2) 
{33, 22}

 s1.difference(s2)　　s1中存在s2中不存在

>>> s1.difference(s2)
{11}

例：

　　现在字典1和字典2如下，要求用字典2去更新字典1，如果字典2中没有的key则在字典1中删除，字典2中有字典1中没有的key则在字典1中建立相应的key.

dict_1 = {
    'cpu':16,
    'mem':8,
    'disk':'1.8T',
    'U位':'25'
}
dict_2 = {
    'cpu':12,
    'mem':16,
    'disk':'3.0T',
    'U位':'15'
}
s1 = set(dict_1.keys())
s2 = set(dict_2.keys())
remove_key = s1.difference(s2)
add_key = s2.difference(s1)
update_key = s1.intersection(s2)
for i in remove_key:
    del dict_1[i]
for i in add_key:
    dict_1[i] = dict_2[i]
for i in update_key:
    if dict_1[i] == dict_2[i]:
        pass
    else:
        dict_1[i] = dict_2[i]


>>> dict_1　　　　　　　　　　　　　　　　　　　　　　　　　　#字典更新完成
{'U位': '15', 'disk': '3.0T', 'cpu': 12, 'mem': 16}

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

以下为一个最简单的函数，每次调用都会打印"this is a test"

def name ():
    print('this is a test')
    return

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

以下为一个函数最简单的调用方法：

def name ():
    print('this is a test')
    return
name()

this is a test

函数参数的传递：

1、普通参数（严格按照顺序，将实际参数赋值给形式参数）
 2、默认参数（必须放置在参数列表的最后）
 3、指定参数（将实际参数赋值给制定的形式参数）
 4、动态参数：
 * 默认将传入的参数，全部放置在元组中
 ** 默认将传入的参数，全部放置在字典中，以key,value的方式显示
5、万能参数, *args,**kwargs

以下为各种传入参数的具体方法：

def test1(x,y):
     print(x,y)
test1(10,20)

10 20


def test2(*args):
    print(args)
test2([1,2,3,4,5])

([1, 2, 3, 4, 5],)                #默认会将传入的参数作为一个元组


def test2(**args):
    print(args)
test2(name='yang',age=18)

{'name': 'yang', 'age': 18}

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

name = 'yang'
def test():
    name = 'zheng'
    age = 28
test()
print(name)

yang

def test2():
    global name
    name = 'zheng'
    age = 28
test2()
print(name)

zheng

在上面的例子中，首先定义了name = 'yang',然后在函数内部重新定义了这个变量，可以看到在函数外部这个变量的值并未改变，而在下面的例子中，用了global声明，此时定义的变量可以在全局范围内使用。

lambda表达式和列表解析

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

  def number (x):
      return x + 1                            #普通方式定义函数
  print(number(123))
  124
  
  
  lambda_1 = lambda x: x+1
  print(lambda_1(123))                 #以lambda表达式方式定义函数
  124        

内置函数

map

遍历序列，对序列中每个元素进行操作，最终获得一个新的序列。

li = [11,22,33]
lst = map(lambda x: x+1,li)
print(list(lst))
>>>[12, 23, 34]                                        #对列表中每个元素都加1

li_1 = [11,22,33]
li_2 = [44,55,66]                           
li_3 = map(lambda a,b: a+b,li_1,li_2)       #用li_1中第一个元素加上li_2中第一个，第二个加第二个，依次相加
print(list(li_3))
>>>[55, 77, 99]

filter

对序列中的元素进行过滤，最终用符合要求的元素再组成一个新的序列。

li = [11, 22, 33]
lst  = filter(lambda x: x > 22, li)
print(list(lst))
>>>[33]

当然，你也可以用列表解析的方法完成上述要求。

li = [11,22,33]
lst = [x+1 for x in li]                     #加1
print(lst)
>>>[12, 23, 34]

li_1 = [11,22,33]
li_2 = [44,55,66]
lst = [(a+b) for a in li_1 for b in li_2 if li_1.index(a) == li_2.index(b) ]      #对应相加
print(lst)
>>>[55, 77, 99]

li = [11,22,33]
lst = [x for x in li if x > 22]             #筛选出大于22的
print(lst)
>>>[33]

　　

　　

 

转载于:https://www.cnblogs.com/postgres/p/5533251.html