python基础（7）--深浅拷贝、函数

print(abs(-10))

#输出10

print(all([1, True, 1 == 1]))

#True

print(any([None, "", [], (), {}, 0, False])) #False

print(any([None, "", [], (), {}, 0, True]) )#True

#通常情况下“空”（None，空字符串、空列表，0等等）都是表示False

print(bin(10))

#'0b1010'

print(bool())  #False

print(bool(10))  #True

print(chr(89999))    #'\U00015f8f'

print(chr(97))    #'a'

print(dict())    #{}

print(dict(k1 = 'v1', k2 = 'v2'))    #{'k1': 'v1', 'k2': 'v2'}

print(dict((['k1', 'v1'], ['k2', 'v2'])))    #{'k1': 'v1', 'k2': 'v2'}

print(dict({'k1':'v1', 'k2':'v2'}))    #{'k1': 'v1', 'k2': 'v2'}

print(dir(""))

#['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

print(divmod(10, 3))

#(3, 1)    返回两个数的得商和余数组成的元组，相当于(a // b, a % b)

enu = enumerate(['abc', 'def', 'ghi'])
print(enu)
for i in enu
    print(i)

'''
返回一个迭代器，每次迭代返回一个元组包括一个计数器，和对iterable迭代取得的值，iterable可迭代对象，包括列表、元祖等。start表示计数器的开始值，默认是0
执行结果
<enumerate object at 0x0000000BE2D53510> # 可以看到返回的是一个enumerate对象
(0, 'abc')
(1, 'def')
(2, 'ghi')
'''

#注意：返回的是是一个迭代器，迭代完了空了，如果需要重复使用，最好转化为一个列表对象保存到变量中，并且计数器是从0开始计数的
li = list(enumerate(['abc', 'def', 'ghi']))
print(li)     #[(0, 'abc'), (1, 'def'), (2, 'ghi')]

#还可以指定start的开始值
li = list(enumerate(['abc', 'def', 'ghi'], 2))
print(li)    #[(2, 'abc'), (3, 'def'), (4, 'ghi')]

print(eval('3 + 4 * (1 - 3)'))   #-5


#将的字符串形式的算数表达式进行计算，并返回结果

def func(num):
    if num % 2 ==0:
        return True
    else:
        return False

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

print(list(filter(func, nums)))


'''
接收一个函数和一个可迭代对象，将可迭代对象的每一个元素都作为参数执行函数，函数返回为真的放到一个新的可迭代对象中，并将新的可迭代对象返回


执行结果
[2, 4, 6, 8, 10, 12, 14, 16, 18]
'''

print('0.5')    #0.5

print(0.5)    #0.5

#创建一个浮点类型的对象

#返回某个对象的帮助信息

print(hex(23))    #'0x17'

#返回一个整数的16进制表达式

print(id(1))    #10455040
#返回对象的id（可以理解为Python为每个对象的编号，或者理解为是Python对象内存地址的表达形式）

s = input('python>>')

print(s)

'''
输入123
输出'123'

接受用户从控制台的输入，并将用户输入的信息，以字符串的返回，prompt表示输入时前显示的字符串
'''

print(int())    #0

print(int('1010', base=2))    #10

#创建一个整数类型的对象，默认如果创建的0，如果传递的是字符串类型的，可以把字符串表达式所表示的整数转化为整数类型，base表示的传递的字符串进制，默认是十进制

print(len('abc'))    #3

#返回一个对象的长度（或者元素的个数）
#所谓的长度一般只字符串，像整数、浮点数等数据类型没有len方法

print(list([1, 2, 3]))    #[1, 2, 3]
prnt(list({'k1':'v1', 'k2':'v2'}))    #['k2', 'k1']

#将一个可迭代对象转化为列表
#可以看到字典只是把key组成了列表，因为字典真正迭代的是key，value只是与key对应而已

s = map(lambda x: x**2, [1, 2, 3])
print(s)    #<map object at 0x0000000002D14CF8>

l = list(map(lambda x: x**2, [1, 2, 3]))
print(l)       #[1, 4, 9]

#接收一个函数和一个可迭代对象，将可迭代对象里的每一个元素都做作为参数传递到函数中，并把函数的返回结果保存到一个map对象中
#函数可以是匿名函数，另外函数必须有返回值，如果没有返回值，虽然不会报错，但没有任何意义，例如

print(max(1, 2, 3))    #3

'''
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
返回可迭代对象中（或者2个以上参数中）最大的值

'''

print(min(1, 2, 3))    #1

'''
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
返回可迭代对象中（或者2个以上参数中）最大的值
'''

print(oct(9))    #'0o11'

#将一个数转化为8进制的表达形式    Python中0o表示8进制

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

　　打开文件并返回文件文件对象，file表示文件名（可以是绝对路径，也可以是相对路径），mode表示打开方式，默认的是rt模式，表示只读的文本格式

'''

print(ord('a'))    #97

#返回一个字符的Unicode编码

print(pow(2, 3)  )    #8

print(pow(2, 3, 3))    #2

#如果只传递两个参数x和y，就计算x的y次方，相当于x ** y
#参数z表示将x ** y的结果对z取模，相当于x ** y % z

'''
    print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

　　打印函数，object表示要输出的对象，sep表示多个对象之间的分隔符，默认是空格，end表示末尾的字符，默认是回车符，file表示输出的文件，默认为sys.stdout也就是终端（标准输出）
'''

print(list(range(1, 10)))    #[1, 2, 3, 4, 5, 6, 7, 8, 9]

print(list(range(1, 10, 2)))    #[1, 3, 5, 7, 9]

print(list(range(5))    #[0, 1, 2, 3, 4]

'''
range(stop)
range(start, stop[, step])
生成大于等于start，小于stop步长为step的数字序列，start默认是0
'''

print(reversed([0, 1, 2, 3, 4]))    #<list_reverseiterator object at 0x7fcc954acd68>

print(list(reversed([0, 1, 2, 3, 4])))    #[4, 3, 2, 1, 0]

#翻转一个序列，序列对象必须是有序的，也就是对象必须包含__reversed__()方法

print(round(1.236, 2))    #1.24

print(round(1.2, 2))    #1.2

#返回一个浮点数的后面保留ndigits位小数的结果，四舍五入，小数点位数不足，不补0

print(set(1, 2, 4, 2))    #{1, 2, 4}

#根据序列对象创建集合对象

print(sorted(['A', 'b', 'c']))    #['A', 'b', 'c']

print(sorted(['A', 'b', 'C']))    #['A', 'C', 'b']

print(sorted(['A', 'b', 'C'], key = lambda x: x.lower()))#['A', 'b', 'C']

print(sorted(['A', 'b', 'C'], key = lambda x: x.lower(), reverse = True))
#['C', 'b', 'A']

#对一个序列对象进行排序，key接收一个函数，将序列的每一个函数处理返回的结果作为排序的依据，比如字符串都转换成小写排序或字典按照key或value排序等，reverse表示对排序的结果是否排序，默认字符串是先大写后小写的顺序排序的

print(str('abc'))    #'abc'

print(str(1234))    #'1234'

#创建一个字符串对象，或者将一个对象转化为字符串对象

print(sum([1, 2, 4]))    #7

print(sum([1, 2, 4], 1))    #8

#返回一个序列对象的相加的总和在加上start，start默认是0，序列对象要么全是数字要么都是字符串，字符串就相当于把它们都拼接在一起

print(tuple())    #()

print(tuple([1, 2, 4]))    #(1, 2, 4)

#创建一个元组对象，或将一个对象转化为元组

print(type(1))    #<class 'int'>

'''
class type(object)
class type(name, bases, dict)
返回一个对象的类型
'''

import sys

vars(sys)
#{'version_info': sys.version_info(major=3, minor=4, micro=0, releaselevel='final', serial=0), 'getswitchinterval': <built-in function getswitchinterval>, '__name__': 'sys', 'path_hooks': [<class 'zipimport.zipimporter'>, <function FileFinder.path_hook.<locals>.path_hook_for_FileFinder at 0x7fcc97b51ae8>],后面省略n多行

#返回模块，类，实例或者任何其他有__dict__属性的对象的__dict__属性，默认是显示当前环境的

x = [1, 2, 3, 4]
y = ['a', 'b', 'c']
print(zip(x, y))    #<zip object at 0x7fcc954aea08>
print(list(zip(x, y)))    #[(1, 'a'), (2, 'b'), (3, 'c')]


#将多个元素组成一个新的zip对象，zip对象的元素个数取决于元素最少的参数