python 集合创建 python中创建集合的函数

集合

一、集合的特性

无序，不重复

 

二、集合的创建方法

1. 大括号

>>> s = {11, 22, 33, 11}
>>> s
{33, 11, 22}

2.初始化函数set

>>> s = set((11,22,33,11))
>>> s
{33, 11, 22}

还可以使用set创建空集合

>>> s = set()
>>> s
set()

 

调用set()函数的时候相当于执行了python中 set类的__init__方法，同样的使用s = {11,22,33}创建集合的时候也调用了set类的 __init__方法。

三、集合的方法

 

1.add方法

向集合中添加一个元素，如果该元素存在，则执行无效

>>> s
{33, 11, 22}
>>> s.add(44)
>>> s
{33, 11, 44, 22}
>>> s.add(11)
>>> s
{33, 11, 44, 22}

 

 2.clear方法

清空集合中的所有元素

>>> s
{33, 11, 44, 22}
>>> s.clear()
>>> s
set()

 

3.copy方法

获得一个集合的副本，并且属于浅拷贝。

>>> s
{33, 11, 22}
>>> s1=s.copy()
>>> s1
{33, 11, 22}
>>> id(s)
11997704
>>> id(s1)
11998376

 

4.difference方法

A.difference(B),在集合A中但不再集合B中

>>> s
{33, 11, 22}
>>> s1 = {22,33,44}
>>> s1
{33, 44, 22}
>>> s.difference(s1)
{11}

 

5. difference_update方法

A.difference_update(B)，类似difference，区别是将结果复制给A.

>>> s
{33, 11, 22}
>>> s1
{33, 44, 22}
>>> s.difference_update(s1)
>>> s
{11}

 

6.discard方法

移除集合中的某个元素，如果该元素不在集合中，则什么也不做。

>>> s1
{33, 44, 22}
>>> s1.discard(22)
>>> s1
{33, 44}
>>> s1.discard(55)
>>> s1
{33, 44}

 

7.remove方法

移除集合中的某个元素，如果该元素不再集合中，则报错

>>> s1
{33, 44, 22}
>>> s1.remove(22)
>>> s1
{33, 44}
>>> s1.remove(55)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 55

 

8.intersection方法

返回两个集合的交集

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

 

9.intersection_update方法

A.intersection_update(B),返回集合A和集合B的交集，并将结果赋值给A

>>> s
{33, 11, 22}
>>> s1
{33, 44, 22}
>>> s.intersection_update(s1)
>>> s
{33, 22}

 

10.symmetric_differece方法

返回两个集合交集的补集

>>> s
{33, 11, 22}
>>> s1
{33, 44, 22}
>>> s.symmetric_difference(s1)
{11, 44}

 

11.symmetric_difference_update方法

A.symmetric_difference_update(B),返回两个集合交集的补集，并将结果赋值给A

>>> s
{33, 11, 22}
>>> s1
{33, 44, 22}
>>> s.symmetric_difference_update(s1)
>>> s
{11, 44}

 

12.union 方法

返回两个集合的并集

>>> s
{33, 11, 22}
>>> s1
{33, 44, 22}
>>> s.union(s1)
{33, 22, 11, 44}

 

13.upadate方法

A.update(B),以集合B扩展集合A

>>> s
{33, 11, 22}
>>> s1
{33, 44, 22}
>>> s.update(s1)
>>> s
{33, 22, 11, 44}

 

14.isdisjoint方法

如果两个集合没有交集的话返回True

>>> s
{33, 22}
>>> s1
{33, 44, 22}
>>> s2
{44, 55}
>>> s.isdisjoint(s1)
False
>>> s.isdisjoint(s2)
True

 

15.issubset方法

A.issubset(B),判断集合A是不是集合B的子集

>>> s
{33, 22}
>>> s1
{33, 44, 22}
>>> s.issubset(s1)
True

 

16.issuperset方法

A.issuperset(B),判断集合A是不是集合B的父集合

>>> s
{33, 22}
>>> s1
{33, 44, 22}
>>> s1.issuperset(s)
True

 

17.pop方法

随机移除集合中的一个元素，并返回该元素

>>> s1
{33, 44, 22}
>>> s1.pop()
33

 

 

函数

函数就是最基本的一种代码抽象的方式。

一、函数的定义

def 函数名（参数）：
     . . .
     函数体
     . . . 
     返回值

定义函数有一下要点：

def     关键字

函数名 用于调用、标识和区别其他函数

函数体 函数中实现逻辑的地方

参数    为函数提供数据，是函数的应用场景更广泛

返回值 函数执行完成后最后返回的值或者标识

 

二、 函数的参数

1、普通参数（位置参数）

def foo(name, passwd)
    print (name, passwd)

foo(xiaoming, 123)

foo(hanmeimei, 456)

函数普通参数，接收特定个数的参数，位置必须对应正确

 

2、默认参数

def foo(name, school='beida')
      return name in school


foo(xiaoming)

xiaoming in beida

foo(hanmeimei)

hanmeimei in beida

默认参数给予参数特定的默认值，函数调用时默认参数如果不指定参数值，则使用默认参数，如果指定参数值，则使用指定参数。

 

3、动态参数1-接收任意数量的位置参数

def foo(*args):
     print args 



foo(11,22,33,44,55,66)

11,22,33,44,55,66

 

4、动态参数2-接收任意数量的关键字参数

def foo(**kwargs):
     print kwargs

foo(name=xiaoming, age=18)

{name:xiaoming, age:18}

 

5、动态参数3-接收任意数量的位置参数和任意数量的关键字参数

def foo(*args, **kwargs):
     print args, kwargs

foo(11,22,33,44,name=xiaoming, age=18)

(11,22,33,44){'name':'xiaoming', 'age':18}

 

三、 内置函数

1.abs()

返回一个数的绝对值。参数可以是整数或浮点数，如果参数是一个复数，将会返回它的模。

 

2.all(iterable)

如果 iterable(迭代器) 中所有元素都为 true (或者iterable 为空)则返回 True。

 

3.any(iterable)

假如iterable 里任意一个元素是True，则返回True。假如iterable是空, 返回 False。

4.ascii(object)

效果如同 repr()，返回一个可打印字符串，但是 repr() 返回的字符串中的非 ASCII 字符使用 \x, \u or \U

 

5.bin(x)

将一个整数转换成一个二进制字符串。结果是一个有效的Python表达式。假如 x 不是一个 Python int 类型的对象, 那它必须定义一个 __index__()

 

6.bytes([source[, encoding[, errors]]])

返回一个新的“bytes”对象，它是一个由0 <= x < 256

 

7.chr(i)

返回一个Unicode编码是整数i的字符串，例如, chr(97)返回字符串 'a'。这个功能与ord()相反。这个参数正确的范围从0 到1,114,111 (十六进制表示是0x10FFFF ). 如果i超出这个范围，将会触发ValueError。

 

8.ord(c)进行

给定一个代表Unicode编码的字符，返回一个代表这个字符的整。

 

 

文件操作

 open函数

该函数生成一个打开的文件句柄，文件句柄很多方法，利用这些方法进行文件操作。

open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True):

打开文件的模式有：

r 只读（默认）

w 只写，写之前会清空文件，对文件进行truncate，不存在则创建。

x 只写，不存在则创建，存在则报错。

a 追加，在文件原有的基础上追加新的内容。

 

+ 模式

r + 读写，用的最多，写之前可以使用seek函数移动文件指针

w + 读写，写之前会清空文件

x + 读写，如果文件存在则报错

a + 读写，追加写

 

b模式

rb 只读，以二进制的方式读文件

wb 只写，以二进制的方式写文件

ab 追加写，以二进制的方式写文件

xb 只写，以二进制的方式写文件

 

文件操作的方法

def close(self, *args, **kwargs): # real signature unknown
        关闭文件
        pass

    def fileno(self, *args, **kwargs): # real signature unknown
        文件描述符  
        pass

    def flush(self, *args, **kwargs): # real signature unknown
        刷新文件内部缓冲区
        pass

    def isatty(self, *args, **kwargs): # real signature unknown
        判断文件是否是同意tty设备
        pass

    def read(self, *args, **kwargs): # real signature unknown
        读取指定字节数据
        pass

    def readable(self, *args, **kwargs): # real signature unknown
        是否可读
        pass

    def readline(self, *args, **kwargs): # real signature unknown
        仅读取一行数据
        pass

    def seek(self, *args, **kwargs): # real signature unknown
        指定文件中指针位置
        pass

    def seekable(self, *args, **kwargs): # real signature unknown
        指针是否可操作
        pass

    def tell(self, *args, **kwargs): # real signature unknown
        获取指针位置
        pass

    def truncate(self, *args, **kwargs): # real signature unknown
        截断数据，仅保留指定之前数据
        pass

    def writable(self, *args, **kwargs): # real signature unknown
        是否可写
        pass

    def write(self, *args, **kwargs): # real signature unknown
        写内容
        pass

    def __getstate__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __next__(self, *args, **kwargs): # real signature unknown
        """ Implement next(self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

View Code

 

管理上下文

with open('file1', 'r') as f1:
     for line in f1：
         . . . . .

with 语句可以自动关闭文件，在with语句快内操作文件

 

在Python 2.7 及以后，with又支持同时对多个文件的上下文进行管理，即：

with open('file1', 'r') as f1, with open('file2', 'r') as f2:
       for line1 in f1:
           for line2 in f2:
               . . . . . .

 

 

lambda表达式

lambda函数也叫匿名函数，即，函数没有具体的名称,而用def创建的方法是有名称的。如下：

lambda语法如下：

lambda [arg1[,arg2,arg3....argN]]:expression

lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值。lambda语句构建的其实是一个函数对象。

如果没有参数，则lambda冒号前面就没有

如果有参数，则lambda冒号就有变量，可以是多个变量用逗号隔开

>>>f1 = lambda:'without canshu'
>>>f1()
'without canshu'

>>>f2 = lambda x,y: x * Y
>>>f2(2,3)
6