'''
set() 函数创建一个无序不重复元素集，可进行关系测试，
删除重复数据，还可以计算交集、差集、并集等。
class set([iterable])
iterable -- 可迭代对象对象；
返回新的集合对象。
'''
# x = set(123445) # int' object is not iterable
x = set(['2',2344,'3'])
y = set('234567')
print(x,y) 
print(x & y )  # 交集 {'3', '2'}
print(x | y ) # 并集  {'3', 2344, '5', '4', '2', '6', '7'}
print(x - y ) # 差集 {2344}
print('-'*10,"分割线","-"*10)

'''
sin() 返回的x弧度的正弦值。
import math
math.sin(x)
注意：sin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
x -- 一个数值。
返回的x弧度的正弦值，数值在 -1 到 1 之间。
'''
import math
print ("sin(10) : ", math.sin(10))
print ("sin(-10) : ", math.sin(-10))
print ("sin(0) : ", math.sin(0)) # 0
print ("sin(math.pi) : ", math.sin(math.pi))
print ("sin(math.pi/2) : ", math.sin(math.pi/2))
print('-'*10,"分割线","-"*10)

'''
setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
setattr(object, name, value)
object -- 对象。
name -- 字符串，对象属性。
value -- 属性值。
无返回值
'''
class A(object):
    item = 1
a = A()
print(a.item) # 1
print(getattr(a,'item')) # 1
print(setattr(a,'item',5)) # None
print(a.item) # 5
# 如果属性不存在会创建一个新的对象属性，并对属性赋值：
setattr(a,'url','www.baidu.com')
print(a.url) # www.baidu.com
print('-'*10,"分割线","-"*10)

'''
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
class slice(stop)
class slice(start, stop[, step])
start -- 起始位置
stop -- 结束位置
step -- 间距
返回一个切片对象。
'''
myslice = slice(5) # 设置截取5个元素的切片
print(myslice) # slice(None, 5, None)arr
arr = range(10) # 
print(arr) # range(0, 10)
print(arr[myslice]) # range(0, 5);返回的arr对象类似于一个迭代器
for i in arr[myslice]:
    print(i)
print('-'*10,"分割线","-"*10)

'''
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，
而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sorted(iterable, key=None, reverse=False)
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回重新排序的列表。
'''
print(sorted([10, 2, 9, 1, 6])) # [1, 2, 6, 9, 10]
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})) # [1, 2, 3, 4, 5]
# key=lambda x: x*-1倒序
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'},key=lambda x: x*-1)) # [5, 4, 3, 2, 1]
dic = {1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}
# 默认是用字典的键排序
print(sorted(dic)) # [1, 2, 3, 4, 5]
# 直接用字典的值排序;记得加括号
print(sorted(dic.values())) # ['A', 'B', 'B', 'D', 'E']
# 用字典的值排序
print(sorted(dic.items(),key = lambda x : (x[1]),reverse=True)) # [(4, 'E'), (1, 'D'), (2, 'B'), (3, 'B'), (5, 'A')]
print('-'*10,"分割线","-"*10)

'''
python staticmethod 返回函数的静态方法。
该方法不强制要求传递参数，如下声明一个静态方法：
class C(object):
    @staticmethod
    def f(arg1, arg2, ...):
        ...
以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()。
函数语法
staticmethod(function)
无参数
'''
class C(object):
    @staticmethod
    def f():
        print('lidihuo')
C.f(); # 静态方法无需实例化 lidihuo
cobj = C()
cobj.f() # 也可以实例化后调用 lidihuo
print('-'*10,"分割线","-"*10)

'''
seed() 方法改变随机数生成器的种子，
可以在调用其他随机模块函数之前调用此函数。。
import random
random.seed ( [x] )
我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。（范围-1-1）
但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，
先调用它的情况下，使用 random() 生成的随机数将会是同一个。
注意：seed()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
x -- 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
本函数没有返回值。
'''
import random
random.seed(10)
print("使用默认种子生成随机数：", random.random()) #  0.5714025946899135
random.seed(10) # 种子不改变，之后生成的随机数相同
print("使用整数 10 种子生成随机数：", random.random()) # 0.5714025946899135
random.seed('1')
print("使用字符串种子生成随机数：", random.random()) 
print("使用字符串种子生成随机数：", random.random()) # 前提，random.random前定义了相同的种子
print('-'*10,"分割线","-"*10)

'''
shuffle() 方法将序列的所有元素随机排序。
import random
random.shuffle (lst )
注意：shuffle() 是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
lst -- 列表。
返回 None。
'''
import random
list = [1, 3, 10, 5]
random.shuffle(list)
print ("随机排序列表 : ", list) # 随机排序列表 :  [5, 10, 3, 1]
random.shuffle(list)
print ("随机排序列表 : ", list) # 随机排序列表 :  [10, 1, 5, 3]
print('-'*10,"分割线","-"*10)

'''
str() 函数将对象转化为适于人阅读的形式。
class str(object='')
object -- 对象。
返回一个对象的string格式。
'''
a = 'sfa'
print(a) # sfa
print(str(a)) # sfa
print('-'*10,"分割线","-"*10)
print('-'*10,"分割线","-"*10)

'''
sum() 方法对系列进行求和计算。
sum(iterable[, start])
iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。
返回计算结果。
'''
print(sum([0,1,10])) # 11
print(sum((1, 2, 3, 4, 5), 1) ) # # 元组计算总和后再加 16
print('-'*10,"分割线","-"*10)

'''
super() 函数是用于调用父类(超类)的一个方法。(理解起来的重难点，这个调用顺序太绕了，好像之前也做过类似的随笔，可以对照参考)
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，
但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
super(type[, object-or-type])
type -- 类。
object-or-type -- 类，一般是 self
Python3.x 和 Python2.x 的一个区别是: 
Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
无返回值
'''
class A(): # Python2.x 记得继承 object
    def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super(B, self).add(x)
b = B()
b.add(2) # 3

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    def bar(self,message):
        print ("%s from Parent" % message)
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild,self).__init__()
        print ('Child')
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')
print('-'*10,"分割线","-"*10)

'''
sqrt() 方法返回数字x的平方根。
import math
math.sqrt( x )
注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
x -- 数值表达式。
返回数字x的平方根。
'''
import math # 导入 math 模块
a = 16
print(math.sqrt(a)) # 4.0
print ("math.sqrt(10) : ", math.sqrt(10))
print ("math.sqrt(7) : ", math.sqrt(7))
print ("math.sqrt(math.pi) : ", math.sqrt(math.pi))