美文网首页
python基础

python基础

作者: John_Phil | 来源:发表于2019-07-11 23:20 被阅读0次

    1.变量、2.运算符、3.分支与循环、4.列表与元组、5.字符串处理、6.字典与集合 、7.变量值与内存、8.函数

    1.变量

    # 单行注解使用井号
    """
    三个双引号
    或
    三个单引号
    为多行注释
    """
    '''
    三个双引号
    或
    三个单引号
    为多行注释
    '''
    studentid='a123'
    studentname='tom'
    print("studentid:",studentid," studentname:",studentname)
    
    price=50.5
    weight=4.5
    sum=price*weight
    print("总价格为",price,"*",weight,"=",sum)
    """判断类型"""
    a1=10
    a2=10.5
    a3=True
    a4=False
    a5="你好"
    a6=[1,2,3,4,5,6,7,8,9]
    a7=(1,2,3,4,5,6,7,8,9)
    a8={'name':'tom','age':18}
    a9={1,2,3,4,5,6,7}
    print(type(a1))
    print(type(a2))
    print(type(a3))
    print(type(a4))
    print(type(a5))
    # list相当于 java中的数组
    print(type(a6))
    # 元组属于不可变列表 此数据类型java中无对应类型
    print(type(a7))
    # 字典相当于java中的map集合
    print(type(a8))
    # 集合相当于java中的集合
    print(type(a9))
    
    # list与set区别
    # 1.有序与无序 过后拓展******************
    
    
    b1=10
    b2=True
    b3=False
    print("10+True=",b1+b2)
    print("10+False",b1+b3)
    
    
    c1 = "aaaa"
    c2 = "bbbb"
    print(c1+c2)
    c3 = 123
    print(c1+str(c3))
    print("a"*3)
    
    d1 = "111"
    d2 = "222"
    d3 = "333.4"
    print(d1+d2)
    print(int(d1)+int(d2))
    print(int(d1)+float(d3))
    
    # 真假
    e1 = 0.1
    e2 = 0
    print(bool(e1))
    print(bool(e2))
    
    # list tuple
    f1 = "123456"
    print(list(f1))
    print(type(list(f1)))
    print(tuple(f1))
    print(type(tuple(f1)))
    # dict set
    f2 = "123"
    f3 = '{"name":"yct","age":10}'
    print(set(f1))
    print(type(set(f1)))
    # print(dict(f3))
    # print(type(dict(f3)))
    print(eval(f3))
    print(type(eval(f3)))
    
    
    # 练习
    ap = input("apple price")
    aw = input("apple weight")
    print("总价为"+str(int(ap)*int(aw)))
    
    # c风格输出 %类似java中的反斜杠 为转义字符 与c语言的输出格式类似
    g1=10
    g2=10.5
    g3=True
    g4="你好"
    g5=[1,2,3,4,5,6]
    g6="%"
    print("g1 is %d g2 is %.2f g3 is %s g4 is %s g5 is %s g6 is %s and %% "%(g1,g2,g3,g4,g5,g6))
    # format 字符串升级写法
    print("format1 g1 is {} g2 is {} g3 is {} g4 is {} g5 is {} g6 is {}  ".format(g1,g2,g3,g4,g5,g6))
    print(f"format2 g1 is {g1} g2 is {g2} g3 is {g3} g4 is {g4} g5 is {g5} g6 is {g6}")
    hname = input("请输入姓名:")
    hcompany = input('公司名称')
    hjob = input('请输入职位')
    hemail=input('邮箱')
    htel=input('电话')
    print("*"*50)
    print(hcompany+"\n")
    print(f"{hname}({hjob})\n")
    print(f"邮箱:{hemail}")
    print(f"电话:{htel}")
    print("*"*50)
    

    2.运算符

    a1=True
    a2=False
    a3=0
    a4=1
    a5=2
    """
    与java不同的运算符  
    1除法自动得小数 想实现取整数 需要使用 //
    2有乘方(幂) 符号为 **
    """
    
    print("10**3=",10**3)
    print("10/3=",10/3)
    print("10//3=",10//3)
    
    print(a1+a2)
    print(a1==a2)
    # 1 是true
    print(a1==a4)#True
    print(a1==a5)#False
    # 取反在python中使用not 在java中使用 !
    # True 不一定为1   非0 皆真
    if(a5):
        print(f"{a5} is True")
    if(not a2):
        print(f"{a2} is false")
    
    # 逻辑运算符
    '''
    逻辑运算符与java不同处
    1. 取反在python中使用not 在java中使用 !
    2. 当为真假时为短路运算
    3. 当为数字时
     # 判断变量是否为0, 是0则为False,非0判断为True,
     # and中含0,返回0; 均为非0时,返回后一个值, 
    2 and 0   # 返回0
    2 and 1   # 返回1
    1 and 2   # 返回2
    # or中, 至少有一个非0时,返回第一个非0,
    2 or 0   # 返回2
    2 or 1   # 返回2
    0 or 1   # 返回1 
    
    '''
    print("False and 10/0:",False and 10/0)
    print("1 and 0:",1 and 0)
    print("0 and 2:",0 and 2)
    print("1 and 2:",1 and 2)
    print("0 or 2 or 3:",0 or 2 or 3)
    print("1 and 2 or 3:",1 and 2 or 3)
    print("3 or 1 and 2 :",3 or 1 and 2)
    print("(3 or 1) and 2 :",(3 or 1) and 2)
    print("1 & 2:",1 & 2)
    print("1 | 2:",1 | 2)
    

    3.分支与循环

    a1=10
    a2=20
    
    """
    if条件与java使用方法一直,语法关键词稍有不同java else if     ----python elif
    python中无switch语句
    """
    if a1==10:
        print("*"*10+"a1==10")
    
    if  a1==15:
        print("*"*10+"a==15")
    else:
        print("*"*10+"a!=15")
    
    
    if a1==10:
        print("*"*10)
    elif a2==20:
        print("#"*10)
    elif a1==10 and a2==20:
        print("^"*10)
    
    """
    循环 与java逻辑一致
    yujava不同点 当没有表达式时 java {} python pass
    
    """
    # 1+2.....+100
    b1=0
    bsum1=0
    while b1<=100:
        bsum1=bsum1+b1
        b1=b1+1
    print(bsum1)
    
    # 大于1000时终止
    b2=0
    bsum2=0
    while b2<=100:
        if bsum2>1000:
           break
        else:
            bsum2=bsum2+b2
            b2=b2+1
    print(bsum2)
    
    # 1+3+5.....99
    b3=0
    bsum3=0
    while b3<=99:
        if b3%2==0:
            b3=b3+1
            continue
        elif 1==2:
            pass
        else:
            bsum3=bsum3+b3
            b3=b3+1
    print("bsum3:"+str(bsum3))
    
    
    """
    for 循环  与Java不同 类似java中的 foreach语句
    for(in)
    
    """
    # 遍历字符串
    for n in  "hello how are you":
        print(n)
    # 遍历数字 利用range(m,n)函数 其实m 共打印 n-m个  最大值为 n-1
    for n in range(1,5):
        print(n)
    
    """
    9*9 算法表
    1*1=1              k1=1  t1=1               规律: t1*k1
    1*2=2 2*2=4         k1=2 t1=1 /t1=2
    1*3=3 2*3=6 3*3=9   k1=3 t1=1/t1=2/t1=3    
    ...
    利用print 打印 自动换行 如果不想换行 使用 end="" 可以不换行
    """
    for k1 in range(1,10):   #行
        for t1 in range(1,k1+1): #列
            result=t1*k1
            print(f"{t1}*{k1}={result}\t",end="")
        print()
    
    """
    随机生成数与java 不同  python随机生成的为左闭右闭  java 生成为随机数 左闭右开
    """
    import random
    # random.randint(a, b) ,返回 [a, b] 之间的整数,包含 a 和 b
    
    k=1
    while k<100:
        n2 = random.randint(1, 10)
        print(n2,end=",")
        k=k+1
    
    

    4列表与元组

    """
    列表 list
    与java中的ArrayList类似
    写法与java数组类似
    """
    al=[1,2,3,4,5,6,7,8]
    # 遍历list
    for n in al:
        print(n)
    #  字符串转 list
    a2="hello how are you"
    print(list(a2))
    # list 转字符串
    a3=['h', 'e', 'l', 'l', 'o', ' ', 'h', 'o', 'w', ' ', 'a', 'r', 'e', ' ', 'y', 'o', 'u']
    a4=""
    for n in a3:
        a4=a4+n
    print(a4)
    # 删除list 及元素
    del a3[0]
    print(a3)
    # del a3
    # print(a3) //list已删除
    # 列表元素处理 append添加到最后   insert 插入到其中 extend将list插入
    # 以上为使用原地址进行拼接  -----原地操作
    b1=[1,2]
    print(b1)
    b1.append(3333)
    print(b1)
    b1.insert(0,9)
    print(b1)
    b1.extend([7,6,5])
    print(b1)
    
    # list改变地址操作 即新生成地址 ----返回新列表
    b2=[1,2]
    print("br2:"+str(b2))
    b3=b2+[3]
    print("br3"+str(b3))
    
    # pop 弹出栈尾   remove 删除指定位置元素(比index大一)  clear 清空list   del 删除指定下表index位置元素
    b3=[1,2,3,4,5,6,7,8]
    print(b3)
    print(b3.pop())
    print(b3)
    print(b3.remove(1))#删除第一个
    print(b3)
    print(b3.clear())
    print(b3)
    
    
    b4=[1,2,3,4,5,6,7,8,1]
    print(b4)
    del b4[1]
    print(b4)
    # 列表访问技术 count计数   in判断是否有 in
    print(b4.count(1))
    # 判断是否有可以用两种方法  count为0 说明无   in 返回 bool
    print(b4.count(9))
    print(9 in b4)
    
    # sort 排序
    b5=[78,2,6,8,3,1,45,21,23]
    print(b5.sort()) #默认升序
    print(b5)
    # 降序三种方法
    # 方法一
    # b5.sort(reverse=True)
    # print(b5)
    # 方法二
    # b5.sort()
    # # b5.reverse()
    # print(b5)
    # 方法三
    # b5.sort()
    # print(list(reversed(b5)))
    # 返回可迭代的zip对象 用法后续拓展
    
    # 返回带下表index的枚举对象
    b6="hello"
    b7=enumerate(list(b6))
    print(b7)
    for k in b7:
        print(k)
    
    # 遍历列表三种方式
    b8=list(b6)
    for k in b8:
        print(k,end="")
    print()
    #range(0,n)与 range(n)等价
    for k in range(len(b8)):
    # for k in range(0,len(b8)):
        print(b8[k],end="")
    print()
    # 遍历枚举类型多个参数值 第一个为下表 第二个参数为值
    for i,ele in enumerate(b8):
        print(f"{i} : {ele}")
    '''
    列表推导式 java中无此方法
    lis = [i for i in range(100)]
    print(lis)
    result=[]
    for i in range(100)
        result.append(i)
    
    '''
    
    lis1 = [i for i in range(100)]
    print(lis1)
    
    result2=[]
    for i in range(100):
       result2.append(i)
    print(result2)
    
    '''
    vec = [[1,2,3], [4,5,6], [7,8,9]]
    list2=[num for elem in vec for num in elem]
    result3=[]
    相当于 
    for elem in vec:
        for num in elem:
            result3.append(num)
    '''
    
    vec = [[1,2,3], [4,5,6], [7,8,9]]
    list2=[num for elem in vec for num in elem]
    print(list2)
    
    result3=[]
    for elem in vec:
        for num in elem:
            result3.append(num)
    print(result3)
    # 过滤
    # 将大于0的重新放到新数组里
    '''
    aList = [-1,-4,6,7.5,-2.3,9,-11]
    list4 =[ n for n in aList if n>0 ]
     相当于 
    result4=[]
    for n in aList:
        if n>0:
            result4.append(n)
            
    '''
    aList = [-1,-4,6,7.5,-2.3,9,-11]
    list4 =[ n for n in aList if n>0 ]
    print(list4)
    
    result4=[]
    for n in aList:
        if n>0:
            result4.append(n)
    print(result4)
    
    """
    print([(x, y) for x in range(3) for y in range(3)])
    list6=[]
    for x in range(3):
        for y in range(3):
            list6.append((x,y))
    """
    
    print([(x, y) for x in range(3) for y in range(3)])
    
    list6=[]
    for x in range(3):
        for y in range(3):
            list6.append((x,y))
    print(list6)
    
    """
    print([(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y])
    list7=[]
    for x in [1, 2, 3]:
        for y in [3, 1, 4]:
            if x != y
                list7.append((x,y))
        
    """
    
    
    print([(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y])
    
    list7=[]
    for x in [1, 2, 3]:
        for y in [3, 1, 4]:
            if x != y:
                list7.append((x,y))
    print(list7)
    
    '''
    解决冒泡排序问题
    实现从小到大排序
    '''
    alist5 = [45,32,31,12,5,2,18,49,1]
    
    for m in range(1,len(alist5)):
        for n in range(0,len(alist5)-m):
            if alist5[n]>alist5[n+1]:
               temp= alist5[n]
               alist5[n]=alist5[n+1]
               alist5[n+1]=temp
    print("alist5:"+str(alist5))
    
    
    
    # 切片
    '''
    这里的索引与java不同 java无负值 python可以设置负值从右向左
    python中的有序序列都支持切片,如字符串,元组,列表。
    '''
    colors = ["red", "blue", "green"]
    print(colors[-1])
    '''
    li[start : end : step]
    默认 step为1
    如果不写前或尾 自动从前到尾
    如果 右超出界限 自动到当前最大值  
    方向
    step = 1
    ---------------------->
    
     -4   -3   -2   -1
    ["A", "B", "C", "D"]
      0    1    2    3
      step=-1
    <--------------------
      
      [0,2]
      从0开始 共2-0个元素
    '''
    li = ["A", "B", "C", "D"]
    t=li[0:3]       # ["A","B","C"]        #起点的0索引可以省略,t=li[:3]
    print(t)
    t=li[2: ]       # ["C","D"]           #省略end,则切到末尾
    print(t)
    t=li[1:3]       # ["B","C"]
    print(t)
    t=li[0:4:2]      #$ ["A","C"]       #从li[0]到li[3],设定步长为2。
    print(t)
    t=li[0:2]
    print(t)
    t=li[0:-2]
    print(t)
    t=li[-4:-2]
    print(t)
    t=li[-4:2]
    print(t)
    
    t=li[-1:-3:-1]
    print(t)   #d c
    
    t=li[::-1]   #  t--->["C","B","A"]     #反向切,切出全部
    
    t=li[:]     #   t--->["A","B","C","D"]   #正向切全部
    
    # 使用切片来原地修改列表内容
    alist6=[1,2,3,4,5,6]
    # 后增加 7,8,9
    alist6[len(alist6):]=[7,8,9]
    print(alist6)
    # 将前三个换为8,9
    alist6[:3]=[8,9]
    print(alist6)
    # 删除前三个
    # 方法一
    alist6[:3]=[]
    print(alist6)
    #方法二
    del alist6[:3]
    print(alist6)
    
    #删除偶数位的元素
    alist7=[1,2,3,4,5,6,7,8,9,10]
    del alist7[1::2]
    print(alist7)
    
    '''
    浅层复制与深层复制问题后续拓展
    https://baijiahao.baidu.com/s?id=1597371058109891101&wfr=spider&for=pc
    '''
    
    '''
    元组 tuple 元组属于不可变序列(元素集合),一旦创建,
    用任何方法都不可以修改其元素。从形式上,元组的所有元素放在一对 圆括 ()号中,
    元素之间用逗号分隔。
    '''
    c1=(1,2,3,4,5,6)
    print(tuple("hello"))  #把字符串转换为元组
    print(tuple(list("hello"))) #把列表转换为元组
    

    5.字符串处理

    '''
    字符串操作
    '''
    #切片方法 同 list中的切片
    s1 = 'www.neuedu.com'
    print(s1[6: 10])
    
    s2 = 'www.NEUEDU.com'
    print(s2.upper())    #### 全部大写
    print(s2.lower())    #### 全部小写
    
    s3 = 'www.neuedu.com'
    print(s3.startswith('www'))    #### 判断是否以www开头
    print(s3.endswith('com'))    #### 判断是否以com结尾
    
    #find找不到-1 index找不到报错
    s4 = 'chhengt'
    print(s4.find('h'))  #### 通过元素找索引找到第一个就返回(可切片)
    print(s4.find('b'))  #### 找不到返回 -1
    # print(s4.index('b'))   #### 找不到会报错
    
    s5 = 'qqwalex qqwusir barryy'
    print(s5.strip('qqw'))
    print(s5.strip(''))
    print(s5.lstrip('yy'))
    print(s5.rstrip('yy'))
    
    # split 把字符串分割成列表
    s61 = 'qqwalex qqwusir barryy'
    s62 = 'qqwale;x qqwu;sir bar;ryy'
    print(s61.split())    #### 默认以空格分割
    print(s62.split(';'))    #### 以指定字符分割
    print(s62.split(';', 1)) #### 指定分割多少个
    
    
    #列表转字符串  join
    
    li = ['aa', 'ddj', 'kk']
    print("".join(li))
    print(",".join(li))
    
    str=""
    for n in li:
        str=str+n;
    print(str)
    
    #### 字符串.isalnum()    所有字符都是数字或者字母,为真返回 Ture,否则返回 False。
    #### 字符串.isalpha()     所有字符都是字母,为真返回 Ture,否则返回 False。
    #### 字符串.isdigit()     所有字符都是数字,为真返回 Ture,否则返回 False。
    #### 字符串.islower()    所有字符都是小写,为真返回 Ture,否则返回 False。
    #### 字符串.isupper()    所有字符都是大写,为真返回 Ture,否则返回 False。
    #### 字符串.istitle()            所有单词都是首字母大写,为真返回 Ture,否则返回 False。
    #### 字符串.isspace()    所有字符都是空白字符,为真返回 Ture,否则返回 False。
    
    #### is 系列
    name = 'taibai123'
    print(name.isalnum()) # True   #### 字符串由数字或字母组成时返回真
    print(name.isalpha()) # False  #### 字符只由字母组成时返回真
    print(name.isdigit()) # False  #### 字符只由数字组成时返回真
    
    #### count 计算字符串中某个字符出现的次数  ***
    s = 'www.neuedu.com'
    print(s.count('u'))
    print(s.count('u', 7))
    
    #replace
    s = 'asdf 之一,asdf也,asdf'
    #### replace  ***
    s1 = s.replace('asdf', '日天')
    print(s1)
    s1 = s.replace('asdf', '日天', 1)
    print(s1)
    
    #### format 格式化输出  ***
    #### 第一种方式:
    s = '我叫{}, 今年{}, 性别{}'.format('小五', 25, '女')
    print(s)
    #### 第二种方式
    s1 = '我叫{0}, 今年{1}, 性别{2},我依然叫{0}'.format('小五', 25, '女')
    print(s1)
    #### 第三种方式
    s2 = '我叫{name}, 今年{age}, 性别{sex},我依然叫{name}'.format(age=25, sex='女',name='小五')
    print(s2)
    #第四种方式
    age=25
    sex='男'
    name='小浏览器'
    s3=f'我叫{name}, 今年{age}, 性别{sex},我依然叫{name}'
    print(s3)
    s = 'chen wuang4fhsa¥fh。f'
    #### capitalize() 首字母大写 **
    s1 = s.capitalize()
    print(s1)
    #center() 将字符串居中可以设置总长度,可以设置填充物 * 默认空格填充
    s = 'chenziwu'
    s2 = s.center(50)
    print(s2)
    s2 = s.center(50, '*')
    print(s2)
    
    # title 非字母隔开的每个单词的首字母大写 *
    s = 'chen wuang4fhsa¥fh。f'
    #### title  非字母隔开的每个单词的首字母大写 *
    s4 = s.title()
    print(s4)
    
    
    # 字符串是不可变变量,不支持直接通过下标修改
    msg = 'abcdefg'
    # msg[2] = 'z' //不可通过下表修改
    
    msg = msg[:2] + 'z' + msg[3:]
    
    print(msg)
    

    6.字典与集合

    """
    字典类型
    相当于java中的map集合
    """
    a_dict={"name":"tom","age":11}
    print(a_dict["name"])
    
    keys = ['a', 'b', 'c', 'd']
    values = [1, 2, 3, 4]
    
    print(zip(keys, values)) #元组压缩
    # zip 转 dict
    print(dict(zip(keys, values)))
    print(type(dict(zip(keys, values))))
    print(list(zip(keys, values)))
    # list->tuple 转 dict
    print(dict(list(zip(keys, values))))
    #特殊写法 转 dict
    d = dict(name='Dong', age=37)
    print(d)
    #list-> 紧有key的dict
    print(dict.fromkeys(["username","password"]))
    
    
    
    print(zip(*zip(keys, values))) #解压 回归二维矩阵
    print(list(zip(*zip(keys, values))))
    a1,b1=list(zip(*zip(keys, values)))
    print(a1)
    print(b1)
    
    
    aDict = {'name':'Dong', 'sex':'male', 'age':37}
    # aDict['name']键不存在,抛出异常
    # 使用字典对象的get方法获取指定键对应的值,并且可以在键不存在的时候返回指定值。
    print(aDict['name'])
    print(aDict.get("name"))
    
    # print(aDict['name1'])
    print(aDict.get("name1","null"))
    aDict={'age': 37,  'name': 'Dong', 'sex': 'male'}
    aDict['score'] = aDict.get('score',[])
    aDict['score'].append(98)
    aDict['score'].append(97)
    print(aDict)
    
    # items()方法可以返回字典的键、值对列表
    print(aDict.items()) # dict_items([('age', 37), ('name', 'Dong'), ('sex', 'male'), ('score', [98, 97])])
    t1=('a','b','b');
    for key in aDict:                       #不加特殊说明,默认输出键
        print(key)
    print(aDict.keys())
    print(aDict.values())
    
    # 使用字典对象的setdefault()方法返回指定“键”对应的“值”,如果字典中不存在该“键”,就添加一个新元素并设置该“键”对应的“值”
    aDict ={'name' : 'Wang','sex' : 'male'}
    aDict.setdefault('age','28')
    print(aDict)
    print(aDict.setdefault('age'))
    print(aDict.setdefault('hobby'))
    print(aDict)
    #
    aDict={'age': 38, 'name': 'Dong', 'sex': 'male'}
    aDict['address'] = 'SDIBT'        #增加新元素
    print(aDict)
    # 使用字典对象的update方法将另一个字典的键、值对添加到当前字典对象
    aDict.update({'a': 'a', 'b': 'b'})
    print(aDict)
    '''
    字典删除
    使用del删除整个字典,或者字典中的指定元素
    使用pop()和popitem()方法弹出并删除指定元素
    使用clear()方法清空字典中所有元素
    '''
    x={}
    x['name']="tom"
    x['age']=20
    print(x)
    x.clear()
    print(x)
    
    x={}
    x['name']="tom"
    x['age']=20
    print(x)
    print(x.popitem())
    print(x)
    
    # 判断key是否在字典中
    d = {'name':'tom', 'age':10, 'Tel':110}
    print(d.keys())
    print ('name'  in d.keys())
    print ('age' in d)
    print("---------------------------------")
    # 遍历dict集合思路
    # 遍历key值 获得value值
    for key in  d:
        print(key+" "+str(d[key]))
    print("---------------------------------")
    for key in d.keys():
        print(key + " " + str(d[key]))
    print("---------------------------------")
    # 获得value值
    for value in d.values():
        print(value)
    print("---------------------------------")
    # 获得item 分别获得key值与value值
    print(d.items())
    for key,value in d.items():
        print(key+" "+str(value))
    print("--------------------------------- 用[] 来降维")
    for item in d.items():
        print(item[0]+" "+str(item[1]))
    print("---------------------------------")
    for (key,value) in d.items():
           print(key+':'+str(value))
    
    # 向dict添加元素极其顺序 目前加入顺序与数据结构顺序一致
    x = dict()
    y = {}
    print(x)
    print(y)
    x['a'] = 3
    x['c'] = 8
    x['b'] = 5
    
    print(x)
    
    import collections
    
    x =collections.OrderedDict()
    x['a'] = 3
    x['c'] = 8
    x['b'] = 5
    print(x)
    for item in x:
        print(item+" "+str(x[item]))
    
    '''
    字典推倒式
    { key_expr: value_expr for value in collection if condition }
    相当于
    for value in collection:
        if condition:
            d[value[1]]=value[0]
            
    '''
    
    strings = ['import','is','with','if','file','exception','liuhu']
    d = {key: val for val,key in enumerate(strings)}
    print(d)
    
    d={}
    for val, key in enumerate(strings):
        d[key]=val
    print(d)
    
    d={}
    for item in enumerate(strings):
        print(item)
        d[item[1]]=item[0]
    print(d)
    # 输出key字符 value为其长度
    s = {strings[i]: len(strings[i]) for i in range(len(strings))}
    print(s)
    k = {k:len(k)for k in strings}
    print(k)
    
    # 练习:同一个字母但不同大小写的值合并起来了。
    mc = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
    mca = {k.lower(): mc.get(k.lower(), 0) + mc.get(k.upper(), 0) for k in mc.keys()}
    print(mca)
    mcb={}
    for k in mc.keys():
         mcb[k.lower()]= mc.get(k.lower(),0)+mc.get(k.upper(),0)  # mc.get(k.lower(),0)  后面的0 是如果为none就是0
    print(mcb)
    
    
    # 集合set相当于java中的collection 下的无序集合 每次输出都可能不同!
    # 自动去除重复 无序
    a = {3, 5}
    a.add(7)
    a.add(2)
    a.add(3)
    a.add(4)
    a.add(6)
    print(a)
    
    a=set()
    print(a)
    # add remove pop del(无当前空间未定义再次调用会报错) clear(清空)
    a = {1, 4, 2, 3}
    print(a)
    print(a.pop())
    print(a.pop())
    a.remove(3)
    print(a)
    a.clear();
    print(a)
    a = {1, 4, 2, 3}
    # del a
    # print(a)
    # update()来使一个集合加入到当前集合中
    a.update({9,8,7,6,5})
    print(a)
    
    #list---->set
    a_set = set([8, 9, 10, 11, 12, 13])
    b_set = {0, 1, 2, 3, 7, 8}
    # 并集
    print(a_set | b_set)
    a_set.union(b_set)
    print(a_set.union(b_set))
    #交集
    print(a_set & b_set)
    print(a_set.intersection(b_set))
    #差集
    print(a_set - b_set)
    print(a_set.difference(b_set))
    #子集
    x={1,2,3}
    y={1,2,3,4}
    print(x.issubset(y))  #子集
    print(x < y)           #真子集
    
    import random
    #随机选择1~500之间的数
    print(random.choice(range(500)))
    # 快速生成 100个1~500的随机数
    listRandom = [random.choice(range(500)) for i in range(100)]
    print(listRandom)
    # 将里面的单一元素进行提取
    noRepeat = []
    for i in listRandom:
        if i not in noRepeat:
            noRepeat.append(i)
    print(noRepeat)
    newSet1 = set(listRandom)
    newSet2 = set(noRepeat)
    print(newSet1)
    print(newSet2)
    
    
    # 集合推导
    s = {x.strip() for x in ('  he  ', 'she    ', '    I')}
    print(s)
    
    
    # 统计单词出现的频次
    word="I'm a boby, I'm a girl. When it is true, it is ture. that are cats, the red is red."
    word=word.replace(',','').replace('.','')
    word=word.split()
    print(word)
    print('第1种方法')
    setword=set(word)
    for i in setword:
        count=word.count(i)
        print(i,'出现次数:',count)
    print('第2种方法')
    dict = {}
    for key in word:
        dict[key] = dict.get(key, 0) + 1
    print(dict)
    print('第3种方法')
    from collections import Counter
    
    result = Counter(dict)
    print(result)
    print(result.most_common(3))
    
    
    # 奥运会足球分组
    # # 已知有十六支男子足球队参加2008 北京奥运会。写一个程序,把这16 支球队随机分为4 个组。采用List集合和随机数
    # #
    # # 2008 北京奥运会男足参赛国家:
    # #
    # # 科特迪瓦,阿根廷,澳大利亚,塞尔维亚,荷兰,尼日利亚,日本,美国,中国,新西兰,巴西,比利时,韩国,喀麦隆,洪都拉斯,意大利
    # #
    # # 提示:分配一个,删除一个
    
    # // map,保存最终分组结果
    # // key保存的是第几组,value是该组对应的国家集合
    import random
    groupNum2Countrys = {}
    
    strCountrys = "科特迪瓦,阿根廷,澳大利亚,塞尔维亚,荷兰,尼日利亚,日本,美国,中国,新西兰,巴西,比利时,韩国,喀麦隆,洪都拉斯,意大利";
    countryList = strCountrys.split(",")
    
    for i in range(4):
        lstGroup = []
        # // 分第1组
        # // 随机从集合中选出一个国家,放到第1组里;然后将这个选出的国家,从原来集合中干掉(删除)
        # // 重复以上步骤4次
        for j in range(4):
            selectIndex = random.randint(0,len(countryList)-1)
            lstGroup.append(countryList[selectIndex])
            countryList.remove(countryList[selectIndex])
    
        groupNum2Countrys[i+1] = lstGroup
    
    for key,value in groupNum2Countrys.items():
        print('第' + str(key) + '组')
        print(value)
    

    7.变量值与内存

    '''
    == 运算符比较两个对象的值(对象中保存的数据),而 is 比较对象的引用(标识)。 通常,我们关注的是值,而不是标识,因此 Python 代码中 == 出现的频率比 is 高。
    java中我们常说 .equals是值  == 是地址
    python中      == 是值      is 是地址
    '''
    
    charles = {'name': 'Charles L. Dodgson', 'born': 1832}
    lewis = charles
    alex = {'name': 'Charles L. Dodgson', 'born': 1832, 'balance': 950}
    
    
    print(lewis is charles) #True  地址相同
    print(alex == charles) #False 值不同
    print(alex is not charles ) #alex 与charles地址不同
    
    '''
    传参数 可以用贴标签来理解
    '''
    
    def f1(a,b):
        a+=b
        return a
    x=1
    y=2
    print(f1(x,y))
    print(x)
    def f1(a,b):
        a+=b
        return a
    x=(1,2)
    y=(3,4)
    print(f1(x,y))
    print(x)
    
    x=[1,2]
    y=[3,4]
    print(f1(x,y)) #原地址不变
    print(x)
    '''
    不可变类型,内存中的数据不允许被修改:
    数字类型 int, bool, float, complex, long(2.x)
    字符串 str
    元组 tuple
    可变类型,内存中的数据可以被修改:
    列表 list
    字典 dict
    自定义类型(class定义的类型,后面讲到)
    
    此处可以类比java中在堆内存中 被修改 地址不变,而栈内存中 数据不可修改 当发生变化地址改变
    '''
    
    

    8.函数

    #定义函数
    def  chengji(a,b):
        return a*b
    
    print(chengji(2,3))
    
    # 函数的好处 重用
    #替换第三个元素
    msg = 'abcdefg'
    msg = msg[:2] + 'z' + msg[3:]
    print(msg)
    msg = '1234567'
    msg = msg[:2] + '9' + msg[3:]
    print(msg)
    
    def insertn(msg,k):
        return str(msg[:2])+str(k)+str(msg[3:])
    print(insertn("123456",9))
    
    
    #函数调用 特殊用法
    '''
    1.调用顺序可调 使用参数赋值
    2.使用默认参数可不赋值
    3.不定长参数
       3.1未命名 *abc    变量为tuple元组
       3.2命名   **abc    dict 字典
    
    '''
    def f(name,age):
        print(name+":"+str(age))
    f("tom",19)
    f(age=18,name="jerry")
    #默认参数
    def  print_info(name,age,sex="male"):
        print(name+":"+str(age)+":"+sex)
    print_info("tomcat2",2)
    print_info("tomcat1",2,"female")
    
    def  a(*tuplea):
        print(tuplea)
    a(1,23,4,5,67)
    
    
    def  a(**abc):
        print(abc)
    a(name="tom",age=12)
    
    
    def print_info(name,*args,**kwargs):#def print_info(name,**kwargs,*args):报错  * 在前   **在后
         print('Name:%s'%name)
         print('args:',args)
         print('kwargs:',kwargs)
    #传值时注意 后面的nickname内部不要与name重名
    print_info("tom",1,2,3,4,nickname="tom",key="asdf")
    
    #将set 与dict 解析 分别使用*  与**
    print_info("jerry",*{1,23,4,5},**{"nickname":"aaa"})
    
    
    # 函数的返回值
    '''
    return多个对象,解释器会把这多个对象组装成一个元组作为一个整体结果输出
    这里与java不同java不能返回多个对象
    
    '''
    def f():
        return 1,2
    print(f())
    
    '''
    高阶函数
    接受一个或多个函数作为输入 输出一个函数
    java中无此用法 类似javascript语法
    '''
    def a(k):
        return k+1
    def b(b,a):
        return a(b)
    print(b(10,a))
    
    def add(x, y, f):
        return f(x) + f(y)
    res = add(3, -6, abs)
    print(res)
    """
    变量获得方法
    
    """
    def method():
        x = 2
    
        def double(n):
            return n * x
    
        return double
    
    
    fun = method()
    print(type(fun)) #class function
    num = fun(20)
    print(num)
    
    '''
    变量作用域
    '''
    x = str(100)  # int built-in
    print('hello' + x)
    
    g_count = 0  # global
    def outer():
        o_count = 1  # enclosing
        def inner():
            i_count = 2  # local
            print(o_count)
        # print(i_count) 找不到
        inner()
    outer()
    
    """
    python中作用域与java不同
    在Python中,只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,
    其它的代码块(如if、try、for等)是不会引入新的作用域的
    """
    if(1==1):
        x=10
    print(x)
    
    
    
    def test():
         x = 2
    print(x) # NameError: name 'x2' is not defined
    
    
    """
     # 错误的原因在于print(x)时,解释器会在局部作用域找,会找到x=5(函数已经加载到内存),但x使用在声明前了,所以报错:
     # local variable 'x' referenced before assignment.如何证明找到了x=5呢?简单:注释掉x=5,x=6
     # 报错为:name 'x' is not defined
     global 可以将变量声明在全局变量 位置
    """
    x=6
    def f2():
         # print(x)
         # global x
         # nonlocal x
         x=5
    
         # x=x+1
    f2()
    print(x)
    
    
    def f4():
        y = 6
        def f3():
    
             nonlocal y
             y=5
    
             # x=x+1
        f3()
        print(y)
    f4()
    # print(y)
    
    '''
    递归函数
    '''
    def factorial_new(n):
    
         if n==1:
             print("1=",end="")
             return 1
         else:
            print(f"{n}*",end="")
            return n*factorial_new(n-1)
    
    print(factorial_new(6))
    
    
    def fibo_new(n):#n可以为零,数列有[0]
    
        if n <= 1:
            return n
        return(fibo_new(n-1) + fibo_new(n-2))
    
    print(fibo_new(10))
    
    # 匿名函数
    # def f(x,y):
    #     temp=x
    #     x=y
    #     y=temp
    #   return (x,y)
    f=lambda x,y:x if x>y else y
    print(f(3,2))
    
    # 求列表[1,2,3,4,5,6,7,8,9],返回一个n*n 的列表
    li=[1,2,3,4,5,6,7,8,9]
    listn=[]
    for  num,n in enumerate(li):
        listn.append(n**2)
    print(listn)
    li=[1,2,3,4,5,6,7,8,9]
    # listn=[]
    for  num,n in enumerate(li):
        li[num]=n*n
        # listn[num]=n*n #IndexError: list assignment index out of range
        print(str(num)+":"+str(n))
    print(li)
    li=[1,2,3,4,5,6,7,8,9]
    # map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回
    print(list(map(lambda x:x**2 ,li)))
    
    # reduce把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:
    # reduce(func,[1,2,3]) 等同于 func(func(1,2),3)
    # 1*2......9 累乘
    from functools import reduce
    li=[1,2,3,4,5,6,7,8,9]
    print(reduce(lambda x,y:x*y,li))
    
    
    # filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
    # 在一个list中,删掉偶数,只保留奇数
    li = [1, 2, 4, 5, 6, 9, 10, 15]
    print(list(filter(lambda x:True if x%2==1 else False ,li)))
    
    # 回数是指从左向右读和从右向左读都是一样的数,例如12321,909。请利用filter()筛选出回数
    #方法一
    print(list(filter(lambda x:True if list(str(x))==list(reversed(str(x))) else False ,list(range(1000)))))
    print(list(filter(lambda x:True if str(x)==str(x)[::-1] else False ,list(range(1000)))))
    #方法二
    str1="abcd"
    print(str1[::-1])
    
    
    # sorted函数 接收一个key函数来实现对可迭代对象进行自定义的排序
    # 可迭代对象:主要与列表,字符串,元祖,集合和字典
    # key:接受一个函数,根据此函数返回的结果,进行排序
    # reverse:排序方向,默认为从小到大,reverse=True为逆向
    
    # 对列表按照绝对值进行排序
    li= [-21, -12, 5, 9, 36]
    print(sorted(li,key=lambda x:abs(x),reverse=False))
    
    # 把下面单词以首字母排序
    li = ['bad', 'about', 'Zoo', 'Credit']
    #方法1 指定位置
    print(sorted(li, key = lambda x : x[0]))
    #方法2 切片
    print(sorted(li, key = lambda x : x[:1]))
    #按字母顺序
    print(sorted(li, key = lambda x : str(x)[0:1].lower()))
    # 假设我们用一组tuple表示学生名字和成绩:
    L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
    # 请用sorted()对上述列表分别按名字排序
    print(sorted(L,key=lambda x:x[0]))
    
    # 再按成绩从高到低排序
    print(sorted(L,key=lambda x:x[1],reverse=True))
    
    
    """
     函数式编程
     函数式编程中的函数这个术语不是指计算机中的函数,而是指数学中的函数,即自变量的映射。
     也就是说一个函数的值仅决定于函数参数的值,不依赖其他状态。比如y=x*x函数计算x的平方根,
     只要x的平方,不论什么时候调用,调用几次,值都是不变的
     命令式编程
     命令式编程是面向计算机硬件的抽象,有变量(对应着存储单元),赋值语句(获取,存储指令),
     表达式(内存引用和算术运算)和控制语句(跳转指令),一句话,命令式程序就是一个冯诺依曼机的指令序列。
    """
    # 把number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]中的正数的平均值
    # 命令式编程
    number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]
    count = 0
    sum = 0
    for i in range(len(number)):
        if number[i]>0:
            count += 1
            sum+=number[i]
    print(sum,count)
    if count>0:
         average = sum/count
    print(average)
    # 函数式编程
    from functools import reduce
    number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]
    positive = filter(lambda x: x>0, number)
    listp=list(positive)
    # print(reduce(lambda x,y:x+y,list(positive)))
    average = reduce(lambda x,y:x+y,listp)/len(listp)
    print(average)
    # 导入整个模块
    # import pizza
    # pizza.make_pizza(16, 'pepperoni')
    # pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
    # 导入特定的函数
    # 若使用这种语法,调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza(),因此调用它时只需指定其名称。
    # from pizza import make_pizza
    #
    # make_pizza(16, 'pepperoni')
    # make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
    # 使用as给函数指定别名
    # from pizza import make_pizza as mp
    # mp(16, 'pepperoni')
    # mp(12, 'mushrooms', 'green peppers', 'extra cheese')
    # 使用as给模块指定别名
    # import pizza as p
    # p.make_pizza(16, 'pepperoni')
    # p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
    # 导入模块中的所有函数 *
    from pizza import *
    help(make_pizza)
    # make_pizza(16, 'pepperoni')
    # make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
    

    pizza.py

    def make_pizza(size, *toppings):
        """概述要制作的比萨"""
        print("\nMaking a " + str(size) +
              "-inch pizza with the following toppings:")
        for topping in toppings:
            print("- " + topping)
    

    相关文章

      网友评论

          本文标题:python基础

          本文链接:https://www.haomeiwen.com/subject/mgqghctx.html