python入门基础

Python入门基础

- IDLE是一个Python Shell，基本上来说是一个通过键入文本与程序交互的途径





一、基础语法

- 输出 print()
  正确写法：

    print('hello world') #hello world
    print("hello world") #hello world
    print("hello world"); #hello world
    print("hello"+"world") #helloworld
    print("hello world" * 3) #hello worldhello worldhello world
    print("hello world\n" * 3) #\m 表示回车意思（将光标移动到下一行）
    					       #hello world
    			               #hello world
    						   #hello world
    print(3+5) #8
    print(123456789123456789*123456789123456789)  #15241578780673678515622620750190521

错误写法

    print 'hello world' #SyntaxError: invalid syntax
    print("hello world\n" + 3) #Traceback (most recent call last):
     						   # File "<pyshell#9>", line 1, in <module>
       						   #   print("hello world\n" + 3)
    						   #TypeError: must be str, not int

- 输入 input()

    temp = input() #输入字符给temp变量（不分类型）
    print(temp) #输出temp内容
    
    temp = input('hello world:') #可以做提示
    print(temp)



- 查看函数  dir()

    dir(__builtins__) #查看有哪些函数

- 如何使用函数 help()

    help(input) #注意查询的函数不用加括号

- 查看变量的类型 type()

    type(True) #<class 'bool'>
    type('520') #<class 'str'>

- 生成从start开始到stop结束的的数字序列 range()

    #语法：
    range(strat,stop,step=1) #前面两个参数可选，第三个参数默认不写值是1表示每次递增多少;如果只传一个参数strat默认从0开始，stop取不包含

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

- 判断类型是否与想要的类型一致 isinstance(变量，类型)
  如果变量和你指定的类型一致 ，则返回True否则返回 False

    print(isinstance('看看',str)) #True 
    print(isinstance('看看',int)) #False

- 断言
  assert这个关键字称之为“断言”，当assert后边的条件为假时，程序自动崩溃并抛出AssertionError异常。一般来说可以用作程序中检查点。
  
- 比较符号

  符号  	含义        
  >   	左边大于右边    
  <   	左边小于左边    
  >=  	左边大于或等于右边 
  <=  	左边小于或等于右边边
  ==  	左边等于右边    
  !=  	左边不等于右边   

    value = 3 > 1
    print(value) #True
    
    value = 3 < 1
    print(value) #False
    
    value = 3 == 1
    print(value) #False

- 算术操作符

    #幂运算
    print(3 ** 3) #27 => 3^3
    print(-3 ** 3) #-27 => -(3^3) 注意：幂运算的优先级比
    
    #除法（有小数，注意：在Python2之前是得到整数）
    print(10/4) #2.5
    
    #除法（整数）
    print(10//4) #2
    
    #取余
    print(10%3) #1

  优先级 	类型   	例如             
  最高  	幂运算  	**             
  ↓   	正负号  	+x 、-x         
  ↓   	算术操作符	*、/、//、+、-     
  ↓   	比较操作符	<、<=、>、>=、==、!=
  ↓   	逻辑运算符	not、and、or     

- 三元操作符

    #语法：
    #如果条件为True值为x反之为y
    x if 条件 else y 

    x,y = 4,5
    if x < y
    	small = x
    else
    	small = y
    
    #可以表达成：
    small = x if x < y else y

- 条件分支

    #语法：
    #格式: 注意缩进和if 和 else 最后有个冒号
    if 条件:
    	#条件为真 True 执行
    else:
    	#条件为假 False 执行

    temp = input('输入一个你想的数字:')
    guess = int(temp)
    if guess == 8:
        print('猜中啦！')
    else:
        if guess > 8:
            print('数字大了')
        else:
            print('数字小了')
    print('结束')

- while循环

    #语法：
    while 条件:
    	#条件为真True执行,如果条件为假False不会进入该循环

- for循环

    #语法：
    for 目标 in 表达式:
    	循环体

    string = 'ABCD' 
    for i in string:  #循环字符长度次数
        print(i , end=' ') #每次打印一个字符,end=' '表示在每打印一个字符结束后加一个空格
    #输出结果:A B C D
    
    string = ['哈哈哈','嘿嘿','嗨']  #定义一个列表
    for i in string:
        print(i,len(i),len(string))#第一个参数：每次打印 第 i 个元组数据
        			   			   #第二个参数：打印第i个元组数据的字符
        			   			   #第三个参数：打印一共有多少个元组
    #输出结果:哈哈哈 3 3
    #		 嘿嘿 2 3
    #		 嗨 1 3

- break 和 continue

    #break: 表示结束循环
    #continue:表示退出当前循环，进入到下一次循环
    
    for i in range(10): # 从0开始到9结束
        if i%2 != 0:  #相当于找出不是2的倍数
            print(i)#1 3 5 7 9
            continue
    
    for i in range(10):
        if i%2 != 0:
            continue
        elif i == 4 : 
            break
        print(i) #0 2        

- 逻辑运算符

  符号  	含义                       	例如                                   
  and 	只有两个都对才是True否则是False     	3>2 and 1<2返回True                    
  or  	只要有1个对就是True,两个都错才是 False	3>2  or 1>2返回True, 3<2  or 1>2返回False
  not 	取反                       	not(True)返回False                     

- 类型转换

转为整型数：int()

    #字符串转为整数
    string = '520'  #定义一个字符串为520
    number = int(string)  #把字符520转为整型给number
    print(value)   #输出整型 520
    
    #浮点类型转为整数
    a = 5.99
    b = int(a)
    print(b) #5 注意：浮点类型转换为整数，Python会采用截断处理把小数点后面的数据直接不要

转为浮点型数：float()

    #字符串转为浮点型数
    string = '520'  
    number = float(string)  
    print(value)   #输出浮点型 520.0
    
    #整数转为浮点型数
    a= 520 
    b = float(a)  
    print(b)   #520.0

转为字符型数：str()

    #整数转为字符串
    number = 520
    string = str(number) 
    print(string)   #输出字符型 '520'
    
    a= 5e19
    b = str(a) 
    print(b)   #输出字符型 '5e19'

二、变量

- 把一个值赋值给一个名字时，他会存储在内存中，称之为变量。在大多数语言中，把这种行为称为“给变量赋值”或者“把值存储在变量中”。不过Python并不算把值存储在变量中，而更像是把名字贴在值的上边。
- 变量可以改变
  1.使用变量之前必须赋值。
  2.可包括字母、下划线、数字、但变量名不能以数字开头。
  3.字母可以大写和小写，但大写和小写是不同的变量。
  4.等号 ‘=’ 表示赋值的意思（变量 = 值）。
  5.变量的命名理论上可以取任何合法的名字，但尽量给变量取一个专业的名字能一眼看懂。
  

三、字符串（英文的单引号或双引号都行，但必须成对）

特殊字符

  符号  	说明        
  \ ' 	单引号       
  \ " 	双引号       
  \a  	发出系统响铃声   
  \b  	退格符       
  \n  	换行符       
  \t  	横向制表符（TAB）
  \v  	纵向制表符     
  \r  	回车符       
  \f  	换页符       
  \o  	八进制数代表的字符 
  \x  	十六进制数代表的字符
  \0  	表示一个空字符   
  \ \ 	反斜杠       

- 带引号的字符

    string = 'Let\'s go!' #方法一：使用转义字符 反斜杠(\)
    string = r'Let\s go!' #方法二：使用原始字符串在前面加上字母 r

- 带反斜杠的字符

    str = 'C:\\now'
    str = r'C:\now' #注意：使用原始字符串不能用\结尾



- 长字符串

    str = '''啦啦啦,
    嘤嘤嘤，
    耶耶耶....
    ''' #使用三引号（可单引号 也可双引号）



常用函数

- 把字符串第一个字符改为大写 capitalize()

    string = 'esther'
    string = string.capitalize()
    print(string) #Esther

- 把整个字符串所有字符转换为小写 casefold()

    string = 'EstHeR'
    string = string.casefold()
    print(string) #esther

- 将字符串居中且使填充至长度width的新字符串 center()

    string = 'esther' 
    string = string.center(20,'*') #第二个参数不写默认为空格
    print(string) #*******esther******* 总共长20

- 检查字符串是否以子字符串结束 endswith()

    string = 'esther'
    print(string.endswith('er')) #True
    print(string.endswith('re')) #False

- 把字符串中的tab符号（\t）转换为空格 expandtabs()

    string = 'esther\tty' 
    string1 = string.expandtabs() #如不指定参数，默认的空格数是 tabsize=8
    string2 = string.expandtabs(tabsize=12) 
    print(string1) #'esther  ty'
    print(string2) #'esther      ty'

- 检测子字符串是否包含在字符串中 find()

    #find(sub[,start[,end]])
    string = 'esther'
    print(string.find('ww')) #-1 没有则返回-1
    print(string.find('er')) #4 有则返回索引值
    
    #index(sub,[start[,end]])
    string = 'esther'
    print(string.index('ww')) #没有会抛出异常
    print(string.index('er')) #4 有则返回索引值

- 检测字符串是否只有字母或数字或中文 isalnum()

    string1 = 'esther11来啦'
    string2 = 'esther 来啦'
    print(string1.isalnum()) #True
    print(string2.isalnum()) #False

- 检测字符串是否只有字母和中文 isalpha()

    string1 = 'esther11来啦'
    string2 = 'esther来啦'
    print(string1.isalpha()) #False
    print(string2.isalpha()) #True

- 检测字符串中是否只有十进制数字 isdecimal()

    #注意：半角数字 和 全角数字（双字节） 都会返回True
    #0-9对应Unicode编码范围：半角——’\u0030’ 到 ‘\u0039’ 全角——’\uff10’到’\uff19’
    string1 = '123' #半角
    string2 = '\uff10' #全角
    print(string1.isdecimal()) #True
    print(string2.isdecimal()) #True

- 检测字符串中是否只有数字 isdigit()

    #注意：半角数字 和 全角数字（双字节）bytes数字 都会返回True
    string1 = '123' #半角
    string2 = '\uff10' #全角
    string3 = b'5'
    print(string1.isdigit()) #True
    print(string2.isdigit()) #True
    print(string3.isdigit()) #True

- 检测字符串中是否没有大写字母 islower()

    string1 = 'hello*//'
    print(string1.islower()) #True

- 检测字符串中是否只有数字字符 isnumeric()

    #注意：半角数字 和 全角数字（双字节） 罗马数字、汉字数字 都会返回True
    string1 = '3' #半角 3
    string2 = '\uff13' #全角 3
    string3 = 'Ⅲ' #罗马 3
    string4 = '三' #汉字 三
    print(string1.isnumeric()) #True
    print(string2.isnumeric()) #True
    print(string3.isnumeric()) #True
    print(string4.isnumeric()) #True

- 检测字符串中是否只有空格 isspace()

    string1 = '     ' 
    string1 = '  q   ' 
    print(string1.isspace()) #True
    print(string2.isspace()) #False

- 检测字符串中是否标题化（所有单词以大写开头其余字母均小写） isupper()

    string1 = 'Esther'
    string2 = 'EstherT'
    print(string1.isupper()) #True
    print(string2.isupper()) #False

- 符串作为分隔符，插入到子字符串中所有的字符之间 join()

    string = '哔哩哔哩' 
    print(string.join('12345')) #1哔哩哔哩2哔哩哔哩3哔哩哔哩4哔哩哔哩5

- 字符串左对齐 ljust()

    string = 'Esther'
    print(string.ljust(10)) #Esther  如不指定参数，默认使用空格填空至长度为10的新字符串
    print(string.ljust(15,'*')) #Esther********* 长度为15的新字符串

- 转换字符串中所有大写字符为小写 lower()

    string = 'EsTHer'
    print(string.lower()) #esther  

- 去掉字符串左边的空格 lstrip()

    string = '     hello world'
    print(string.lstrip()) #hello world

- 去掉字符串右边的空格  rstrip() 

    string = 'hello world      '
    print(string.rstrip()) #hello world

- 去掉字符串两边空格 strip()

    string = '      hello world      '
    print(string.strip()) #hello world 不传参默认删除前后空格
    print(string.strip('h')) #ello world 默认删除前后空格和 h

- 找到子字符串把字符串分成3个元组 partition()

    string = 'hello world'
    print(string.partition('wo')) #('hello ', 'wo', 'rld')
    print(string.partition('ee')) #('hello world', '', '') 注意：如果字符串中不包含子字符串则返回（'原字符串','',''）

- 替换新的字符串 replace()

    string = 'hello world' 
    print(string.replace('hello','Hi'))  #Hi world

- 字符串分隔成列表 split() 

    string = 'hello world' 
    print(string.split())  #['hello', 'world'] 注意：默认不传参是以空格分隔
    print(string.split('o'))  #['hell', ' w', 'rld']

- 翻转字符串的大小写 swapcase()

    string = 'EstHeR'
    string = string.swapcase()
    print(string) #eSThEr

- 把所有小写字符转换为大写 upper()

    string = 'EstHeR'
    string = string.upper()
    print(string) #ESThER

字符串格式化

- 字符串格式化方法

    str = "{0} love {1}.{2}".format("I","Love","you")
    print(str) #'I love Love.you'
    
    str = "{a} love {b}.{c}".format(a="I",b="Love",c="you")
    print(str) #'I love Love.you'
    
    str = "{0} love {b}.{c}".format("I",b="Love",c="you")
    print(str) #'I love Love.you'
    
    str = "{0:.1f}{1}".format(27.658,"GB")
    print(str) #'27.7GB'

- 字符串格式化符号含义

  符号  	说明                        
  %c  	格式化字符及其 ASCII 码           
  %s  	格式化字符串                    
  %d  	格式化整数                     
  %o  	格式化无符号八进制数                
  %x  	格式化无符号十六进制数               
  %X  	格式化无符号十六进制数（大写）           
  %f  	格式化浮点数字，可指定小数点后的精度        
  %e  	用科学计数法格式化浮点数              
  %E  	作用同 %e，用科学计数法格式化浮点数       
  %g  	根据值的大小决定使用 %f 或 %e        
  %G  	作用同 %g，根据值的大小决定使用 %f 或者 %E

    #%c运用
    print('%c' % 'a') #97 注意：ASCII码a是数字97
    print('%c %c %c' % ('97,98,99') #'a b c'
    print('%c' % 97) #a 注意：ASCII码97是字符 a
    
    #%s运用
    print('%s' % 'hello world') #'hello world'
    
    #%d运用
    print(' %d + %d = %d' % (4,5,4+5)) #'4 + 5 = 9'
    
    #%o运用
    print('%o' % 10)  #'12'  注意：是以8进制格式打印出来  
    
    #%x运用
    print('%x' % 10) #'a' 注意：是以16进制格式打印出来  
    
    #%X运用
    print('%X' % 10) #'A' 注意：是以16进制大写格式打印出来  
    
    #%f运用
    print('%f' % 27.658)  #'27.658000' 注意：默认是6位小数没有是会补0
    print('%.2f' % 27.658) #'27.66' 注意：显示2位小数
    
    #%e运用
    print('%e' % 27.658)  #'2.765800e+01'
    
    #%E运用
    print('%E' % 27.658) #'2.765800E+01'
    
    #%g运用
    print('%g' % 27.658) #'27.658'
    
    #%G运用
    print('%G' % 27.658) #'27.658'

- 格式化操作符辅助命令

  符号  	说明                                   
  m.n 	m 是显示的最小总宽度，n 是小数点后的位数               
  -   	用于左对齐                                
  +   	在正数前面显示加号（+）                         
  #   	在八进制数前面显示 '0o'，在十六进制数前面显示 '0x' 或 '0X'
  0   	显示的数字前面填充 '0' 取代空格                   

    # m.n 运用
    print('%5.1f' % 27.658) #' 27.7' 注意：要显示最小总宽度为5，前面有一个空格（可以省略m）
    print('%.2f' % 27.658)  #'27.66 
    
    # - 运用
    print('%10d' % 5)  #'         5' 
    print('%-10d' % 5) #'5         '
    
    # + 运用
    print('%+d' % 5) #'+5'
    print('%+d' % -5) #'-5'
    
    # # 运用
    print('%#o' % 10) #'0o12' 
    print('%#X' % 108) #'0X6C'
    print('%#d' % 10) #'10'
    
    # 0 运用
    print('%010d' % 5)  s#'0000000005'
    print('%-010d' % 5) #'5         '

三、random模块

- randint()： 返回随机的一个整数

    import random #使用某个模块时需要先导入该模块
    secret = random.randint(1,10) #设定随机数为1——10的整数数字
    temp = input('输入一个你想的数字:')
    guess = int(temp)
    while guess !=secret:
        temp = input('猜错了请重新输入:')
        guess = int(temp)
        if guess == secret:
            print('猜中啦！')
        else:
            if guess > secret:
                print('数字大了')
            else:
                print('数字小了')
    print('结束')

四、数值类型

- 整型：  表示整数
- 浮点型：  带有小数点，对于位数很多的数字，可以用e记法表示（e代表10，后面表示10的多少次方）

    print(15e4) #150000.0
    print(0.00000000000000000012) #1.2e-19

- 布尔类型： 可以用True或False表示，也可以当做整数看True表示1，False表示0（一般不推荐）

    print(True + True) #2
    print(True + False) #1
    print(True * False) #0

五、列表

创建列表

- 普通列表

    string = ['小明','小王','小李']
    print(string) #['小明', '小王', '小李']
    
    number = [1,2,3]
    print(string) #[1,2,3]

- 混合列表

    value = ['小明',2,5.02,[1,2,3]]
    print(value) #['小明',2,5.02,[1,2,3]]

- 空列表

    empty = []
    print(empty) #[]

向列表添加元素

- 添加单个元素  append()

    string = ['小明','小王','小李']
    string.append('小张') #注意：只能追加到末尾
    print(string) #['小明', '小王', '小李','小张'] 

- 添加多个元素 extend()

    string = ['小明','小王','小李']
    string.extend(['小张','小赵']) #注意：只能追加到末尾，且追加多个时需用[],用逗号隔开
    print(string) #['小明', '小王', '小李','小张','小赵'] 

- 插入一个元素位置自定 insert()

    #插入第一个位置
    string = ['小明','小王','小李']
    string.insert(0,'小张') #注意：列表的索引是从0开始的
    print(string) #['小张','小明', '小王', '小李'] 
    
    #插入中间位置
    string = ['小明','小王','小李']
    string.insert(len(string)//2,'小张') 
    print(string) #['小明','小张', '小王', '小李'] 

互换元素的位置

    string = ['小明','小张', '小王', '小李']
    #我想让 小张 和 小王 互换一下位置
    #首先你得知道小张位于string[1]，小王是位于string[2]
    #互换先把小张放入一个临时变量， 然后把小王放入第一个string[1]里面，然后再把临时变量里面的值赋给string[2]
    temp = string[1] #把小张放入一个临时变量
    string[1] = string[2] #把小王放到第一个string[0]
    string[2] = temp #把临时变量里面的值赋给string[2]
    print(string) #['小明','小王', '小张', '小李']

列表删除元素

- 通过名字来删除 remove()

    string = ['小明','小张', '小王', '小李']
    string.remove('小张') #如果输入的元素列表中没有则报错
    print(string) #['小明', '小王', '小李']

- 通过索引删除 或 整个列表删除 del (不是方法是一个语句)

    #通过索引删除
    string = ['小明','小张', '小王', '小李']
    del string[0]
    print(string) #['小张', '小王', '小李']
    
    #整个列表删除
    string = ['小明','小张', '小王', '小李']
    del string
    print(string) #NameError: name 'string' is not defined

- 从列表中取出一个元素删除 pop()

    #删除最后一个元素
    string = ['小明','小张', '小王', '小李']
    str = string.pop() 
    print(str) #'小李'
    print(string) #['小明','小张', '小王']
    
    #通过索引删除
    string = ['小明','小张', '小王', '小李']
    str = string.pop(1) 
    print(str) #'小张'
    print(string) #['小明', '小王', '小李']

列表分片（拷贝）

- 部分拷贝

    string = ['小明','小张', '小王', '小李']
    str = string[1:3] #从索引1开始取值,取到索引为2（3是不包含的）
    print(str) #['小张', '小王']
    
    string = ['小明','小张', '小王', '小李']
    str = string[:3] #从索引0开始取值,取到索引为2
    print(str) #['小明','小张', '小王']
    
    string = ['小明','小张', '小王', '小李']
    str = string[1:] #从索引1开始取值,取到结尾
    print(str) #['小张', '小王', '小李']

- 全部拷贝

    string = ['小明','小张', '小王', '小李']
    str = string[:] 
    print(str) #['小明','小张', '小王', '小李']

列表的常用操作符

- 比较操作符

    list1 = [123,456]
    list2 = [124,123]
    print(list1 > list2) #False 注意：是拿第一个元素进行比较

- 逻辑操作符

    list1 = [123,456]
    list2 = [124,123]
    list3 = [124,456]
    print((list1 < list2) and (list1 == list3)) #True

- 连接操作符

    list1 = [123,456]
    list2 = [124,123]
    list3 = list1 + list2
    print(list3) #[123,456,124,123]

- 重复操作符

    list1 = [123,456]
    print(list1 * 3) #[123,456,123,456,123,456]

- 成员关系操作符(看列表里面是否有要找的元素)

    list1 = [123,456,'小明','阿巴阿巴']
    print('小明' in list1) #True 查找是否有小明这个元素  
    print('小王' not in list1) #True 查找是否没有小王这个元素  
    
    list2 = [123,456,'小明','阿巴阿巴',['小王',123]]
    print('小王' in list1) #False 
    print('小王' in list1[4]) #True 

查询元素出现次数 count()

    list1 = [123,456]
    list1 *= 5 #list1 = list1 * 5
    list1.count(123) #5

查询元素出现位置 index()

    list1 = [123,456]
    list1 *= 5 #list1 = list1 * 5
    #第一次出现位置
    list1.index(123) #0
    #根据范围出现位置
    list1.index(123,3,6) #4 看看123从索引为3到索引为6在列表第一次出现的位置

列表翻转 reverse()

    list1 = [123,456,789]
    list1.reverse() 
    print(list1) #[789,456,123]

列表排序 sort()

- 从小到大进行排序

    list1 = [9,5,6,2,7,8,1,3,4,10]
    list1.sort() #默认是从小到大进行排序
    print(list1) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

- 从大到小进行排序

    #方法一
    list1 = [9,5,6,2,7,8,1,3,4,10]
    list1.sort() 
    list1.reverse() 
    print(list1) [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    
    #方法二
    list1 = [9,5,6,2,7,8,1,3,4,10]
    list1.sort(reverse=True) #默认为False，表示从小到大进行排序，如果为True则表示从大到小进行排序
    print(list1) [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

六、元组（不可直接更改，用跟列表差不多）

创建元组

- 普通元组（可以省略小括号）

    tuple = ('小明','小王','小李')
    print(tuple) #('小明', '小王', '小李')
    
    tuple = (1,2,3)
    print(tuple) #(1,2,3)
    

- 单个元组（需要在后面加一个逗号）

    tuple = (1)
    print(tuple) #1 注意：不是元组类型 是整型
    print(type(tuple)) #<class 'int'>
    
    tuple = (1,)
    print(tuple) #(1,)
    print(type(tuple)) #<class 'tuple'>

- 混合元组

    value = ('小明',2,5.02,(1,2,3))
    print(value) #('小明', 2, 5.02, (1, 2, 3))

- 空元组

    empty = ()
    print(empty) #()

- 元组的多次增加

    tuple = 3 * (1,)
    print(tuple) #(1, 1, 1)
    
    #如果不写逗号
    tuple = 3 * (1)
    print(tuple) #3

更新元组

- 插入一个元素位置自定

    #插入第一个位置
    string = ('小明','小王','小李')
    string = ('小张',) + string[:]
    print(string) #('小张', '小明', '小王', '小李')
    
    #插入中间位置
    string = ('小明','小王','小李')
    string = string[:1] + ('小张',) + string[1:]
    print(string) #('小明', '小张', '小王', '小李')
    
    #插入最后位置
    string = ('小明','小王','小李')
    string =  string[:] + ('小张',)
    print(string) #('小张', '小明', '小王', '小李')

删除元组（一般不使用）

    #语法
    del 数组名字

七、序列

列表、元组、字符串共同点

- 都可以通过索引得到每一个元素
- 默认索引值从0 开始
- 可以通过分片的方法得到一个范围内的元素集合
- 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

常用函数

- 把一个可迭代对象转换为列表 list()

    str = 'hello world'
    print(list(str)) #['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
    
    num = (1,21,4,9)
    print(list(num)) #[1, 21, 4, 9]

- 把一个可迭代对象转换为元组 tuple()

    str = 'hello world'
    print(tuple(str)) #('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
    
    num = [1,21,4,9]
    print(tuple(num)) #(1, 21, 4, 9)

- 返回参数长度 len()

    str = 'hello world'
    print(len(str)) #11

- 返回序列或者参数集合中最大值 max()

    #注意：要保证数据类型统一
    str = 'hello world'
    num = (1,21,4,-24)
    print(max(str)) #w 注意：每个字符都有个ASCII 码，根据ASCII码比较最大值
    print(max(num)) #21 

- 返回序列或者参数集合中最小值 min()

    #注意：要保证数据类型统一
    str = '1234567890'
    num = (1,21,4,-24)
    print(min(str)) #0
    print(min(num)) #-24 

- 返回序列和可选参数的总和 sum()

    #注意：要保证数据类型统一
    num = (3.1,2.3,3.4) 
    str = '1234567890'
    print(sum(str)) #报错
    print(sum(num)) #8.8
    print(sum(num,8)) #16.8 注意：第二个参数可以不写，如果有则前面总和加上后面的参数

- 对序列进行从小到大排序 sorted()

    num = (1,21,4,-24)
    print(sorted(num)) #[-24, 1, 4, 21]

- 翻转列表返回一个集合对象 reversed()

    num = (1,21,4,-24)
    print(reversed(num)) #<reversed object at 0x000001CC43014C88> 注意：这里是一个对象，可以通过list()方法得到值
    print(list(reversed(num))) #[-24, 4, 21, 1]

- 枚举 enumerate()

    num = (1,21,4,-24)
    print(enumerate(num)) #<enumerate object at 0x000001CC4309B900>
    print(list(enumerate(num))) #[(0, 1), (1, 21), (2, 4), (3, -24)]

- 返回由各个参数的序列组成的序列 zip()

    a = [1,2,3,4,5,6,7,8]
    b = [5,6,7,8]
    print(zip(a,b)) #<zip object at 0x000001CC4309ADC8>
    print(list(zip(a,b))) #[(1, 5), (2, 6), (3, 7), (4, 8)]