Day 1-3 Pyhon 基础学习

#海龟绘图
'''
    import turtle
    turtle.write("马浩轩")
    turtle.showturtle()
    turtle.forward(300)
    turtle.color("red")
    turtle.left(90)
    turtle.forward(300)
    turtle.penup()
    抬起笔，不出现笔迹
    turtle.goto(0, 50)
    turtle.goto(0, 0)
    turtle.pendown()
    turtle.circle(100)
    画半径为100的圆
    t = turtle.Pen()

    for x in range(6):
        t.forward(x)
        t.left(89)
'''

#链式赋值
'''
    a,b,c=4,5,6 相当于：a=4;b=5;c=6
    a,b=1,2
    a,b=b,a 交换赋值
'''

#基本运算
'''
    a = 9 / 4   # 浮点数除法
    b = 9 // 4  # 整数除法
    c = 9 % 4   # 取模(余数)运算
    d = 2**3    # 幂运算
    e = divmod(13, 3) # 同时得到商和余数

'''

#进制转换
''' 
    0b 或 0B，二进制 0 1 
    0o 或 0O，八进制 0 1 2 3 4 5 6 7 
    0x 或 0X，十六进制 0 1 2 3 4 5 6 7 8 9 a b c d e f
'''

#类型转换

'''
    a = int(9.9)
    b = int("456")
'''

#增强型赋值运算符
'''
    += a += 2 a = a + 2 
    -= a -= 2 a = a-2 
    *= a *= 2 a = a * 2 
    /= a /= 2 a = a / 2 
    //= a //= 2 a = a//2 
    **= a **= 2 a = a**2 
    %= a %= 2 a = a % 2
'''

#运算符
'''
    同一运算符: 
        is 判断两个标识符是不是引用同一个对象
    
    is 与 == 区别： 
        is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。 
        == 用于判断引用变量引用对象的值是否相等，默认调用对象的 __eq__()方法。
    
    优先级：
        1. 乘除优先加减 
        2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符
'''

#字符串的编码
'''
    使用内置函数 ord()可以把字符转换成对应的 Unicode 码； 
    使用内置函数 chr()可以把十进制数字转换成对应的字符。
'''

#引号创建字符串
'''
    通过单引号或双引号创建字符串
        例：b = 'my_name is "TOM"'
    连续三个单引号或三个双引号，可以创建多行字符串
        例：resume = “”“name="gaoqi" company="sxt" age=18 lover=’Tom‘”“”
    len()用于计算字符串含有多少字符
        d = 'abcdef' len(d)=6
    '''

#转义字符
'''
    
    \(在行尾时) 续行符 
    \\ 反斜杠符号 
    \' 单引号 
    \" 双引号 
    \b 退格(Backspace) 
    \n 换行 a = 'I\nlove\nU
    \t 横向制表符 
    \r 回车
'''

#字符串拼接
'''
    使用+将多个字符串拼接起来
        例：’aa’+ ’bb’ ==>’aabb
    将多个字面字符串直接放到一起实现拼接
        例：’aa’’bb’   ==>’aabb’
'''

#字符串复制
'''
    使用*可以实现字符串复制
        例：a = 'Sxt'*3 ==>'SxtSxtSxt'
'''

#不换行打印
'''
    print("sxt",end=' ') 
    print("sxt",end='##')
    print("sxt")
    ==>sxt sxt##sxt
'''

#从控制台读取字符串
'''
   使用 input()从控制台读取键盘输入的内容
        例：myname = input("请输入名字:")
'''

#str()实现数字转型字符串
'''
    str(5.20) ==> ‘5.20’ 
    str(3.14e2)==>’314.0’ 
    str(True) ==> ‘True’
'''

#使用[]提取字符
'''
    字符串的本质就是字符序列:
        a = 'abcdefghijklmnopqrstuvwxyz'
    正向搜索： 最左侧第一个字符，偏移量是 0，第二个偏移量是 1，以此类推。直到 len(str)-1 为止
        a[0]    ==> a
        a[3]    ==> d
        a[26-1] ==> z 
    反向搜索： 最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2，以此类推，直到-len(str) 为止
        a[-1]   ==> z 
        a[-26]  ==> a
        '''

#replace()实现字符串替换
'''
   创建新的字符串来实现
        a = 'abcdefghijklmnopqrstuvwxyz'
        a = a.replace('c','高')
        ==> ab高defghijklmnopqrstuvwxyz'
        
'''

#字符串切片 slice 操作
'''
    字符串最左侧是0
       “abcdef”[:]     “abcdef”
       “abcdef”[2:]    “cdef”
       “abcdef”[:2]    “ab”
       “abcdef”[2:4]   “cd”
       “abcdef”[1:5:2] “bd” 从 start 提取到 end-1，步长是 step
    字符串最右侧是-1
        "abcdefghijklmnopqrstuvwxyz"[-3:]      “xyz”
        "abcdefghijklmnopqrstuvwxyz"[-8:-3]    ”stuvw“ 包头不包尾！
        "abcdefghijklmnopqrstuv wxyz"[::-1]    "zyxwvutsrqponmlkjihgfedcba"
'''

#split()分割和 join()合并
'''
    split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。
        如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)
        a = "to be or not to be" 
        >>> a.split() 
        ==> ['to', 'be', 'or', 'not', 'to', 'be']
    join()的作用和split()作用刚好相反，用于将一系列子字符串连接起来
        a = ['sxt','sxt100','sxt200'] 
        >>> '*'.join(a) 
        ==> 'sxt*sxt100*sxt200'
'''

#常用查找方法
'''
    len(a) 字符串长度 96
    a.startswith('我是高淇')   以指定字符串开头 True 
    a.endswith('过我')        以指定字符串结尾 True
    a.find('高')              第一次出现指定字符串的位置 2 
    a.rfind('高')             最后一次出现指定字符串的位置 29 
    a.count("编程")            指定字符串出现了几次 3 
    a.isalnum()               所有字符全是字母或数字 False
'''

#去除首尾信息
'''
    通过 strip()去除字符串首尾指定信息。
    通过 lstrip()去除字符串左边指定信息， 
    通过rstrip()去除字符串右边指定信息。
'''

#大小写转换
'''
    a.capitalize() 产生新的字符串,首字母大写 'Gaoqi love programming, love sxt' 
    a.title() 产生新的字符串,每个单词都首字母大写 'Gaoqi Love Programming, Love Sxt' 
    a.upper() 产生新的字符串,所有字符全转成大写 'GAOQI LOVE PROGRAMMING, LOVE SXT' 
    a.lower() 产生新的字符串,所有字符全转成小写 'gaoqi love programming, love sxt
    a.swapcase() 产生新的,所有字母大小 写转换 'GAOQI LOVE PROGRAMMING, LOVE sxt
'''

#格式排版
'''
    center()、ljust()、rjust()这三个函数用于对字符串实现排版。
        a="SXT" 
        >>> a.center(10,"*") '***SXT****' 
        >>> a.center(10) ' SXT ' 
        >>> a.ljust(10,"*") 'SXT*******
'''

#其他方法
'''
    1. isalnum() 是否为字母或数字 
    2. isalpha() 检测字符串是否只由字母组成(含汉字)。 
    3. isdigit() 检测字符串是否只由数字组成。 
    4. isspace() 检测是否为空白符 
    5. isupper() 是否为大写字母 
    6. islower() 是否为小写字母
'''

#format()基本用法
'''
    b = "名字是{0}，年龄是{1}。{0}是个好小伙"
    c = b.format("高淇",18)
    d = "名字是{name}，年龄是{age}" 
    d.format(age=19,name='高淇') 
    '名字是高淇，年龄是 19
'''

#数字格式化
'''
    3.1415926 {:.2f} 3.14 保留小数点后两位 
    3.1415926 {:+.2f} 3.14 带符号保留小数点后两位 
    2.71828 {:.0f} 3 不带小数 
    5 {:0>2d} 05 数字补零 (填充左边, 宽度为 2) 
    5 {:x<4d} 5xxx 数字补 x (填充右边, 宽度为 4) 
    10 {:x<4d} 10xx 数字补 x (填充右边, 宽度为 4) 
    1000000 {:,} 1,000,000 以逗号分隔的数字格式 
    0.25 {:.2%} 25.00% 百分比格式 
    1000000000 {:.2e} 1.00E+09 指数记法 
    13 {:10d} 13 右对齐 (默认, 宽度为 10) 
    13 {:<10d} 13 左对齐 (宽度为 10) 
    13 {:^10d} 13 中间对齐 (宽度为 10)
'''

#列表对象的常用方法
'''
    list.append(x)          增加元素        将元素 x 增加到列表 list 尾部 
    list.extend(aList)      增加元素        将列表 alist 所有元素加到列表 list 尾部 
    list.insert(index,x)    增加元素        在列表 list 指定位置 index 处插入元素 x 
    list.remove(x)          删除元素        在列表 list 中删除首次出现的指定元素 x 
    list.pop([index])       删除元素        删除并返回列表 list 指定为止 index 处的元素，默认是 最后一个元素 
    list.clear()            删除所有元素     删除列表所有元素，并不是删除列表对象 
    list.index(x)           访问元素        返回第一个 x 的索引位置，若不存在 x 元素抛出异常 
    list.count(x)           计数           返回指定元素 x 在列表 list 中出现的次数 
    len(list)               列表长度        返回列表中包含元素的个数 
    list.reverse()          翻转列表        所有元素原地翻转 
    list.sort()             排序           所有元素原地排序 a.sort(reverse=True) #降序排列
    list.copy()             浅拷贝         返回列表对象的浅拷贝
'''

#range()创建整数列表
'''
    range()可以帮助我们非常方便的创建整数列表
    语法格式为： range([start,] end [,step])
        list(range(3,15,2)) 
        ==>[3, 5, 7, 9, 11, 13]
    结尾的不放入
'''

#复制列表所有的元素到新列表对象
'''
    list1 = [30,40,50] 
    list2 = [] + list1
'''

#多维列表
'''
    a = [ ["高小一",18,30000,"北京"], ["高小二",19,20000,"上海"], ["高小一",20,10000,"深圳"], ] 
    for m in range(3): 
        for n in range(4): 
            print(a[m][n],end="\t") 
        print() #打印完一行，换行
'''

#元组 tuple
'''
    列表属于可变序列，可以任意修改列表中的元素。 索引下标从0开始
    元组属于不可变序列，不能修改元组中的元素。
    元组没有增加元素、修改元素、删除元素相关的方法。
    
    1. 通过()创建元组。小括号可以省略 如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数 1，(1,) 解释为元组。
    2. 通过 tuple()创建元组
        b = tuple() #创建一个空元组对象 b = tuple("abc") 
        b = tuple(range(3)) 
        b = tuple([2,3,4])

    #元组总结
    1. 元组的核心特点是：不可变序列。 
    2. 元组的访问和处理速度比列表快。 
    3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。
'''

#zip
'''
    zip(列表 1，列表 2，...)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象
        >>> a = [10,20,30] 
        >>> b = [40,50,60] 
        >>> c = [70,80,90] 
        >>> d = zip(a,b,c) 
        >>> list(d) 
        ==>[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

'''

#字典的创建
'''
    1. 我们可以通过{}、dict()来创建字典对象
        >>> a = {'name':'gaoqi','age':18,'job':'programmer'} 
        >>> b = dict(name='gaoqi',age=18,job='programmer') 
        >>> a = dict([("name","gaoqi"),("age",18)]) 
        >>> c = {} #空的字典对象 
        >>> d = dict() #空的字典对象
    
    2. 通过 zip()创建字典对象
        >>> k = ['name','age','job'] 
        >>> v = ['gaoqi',18,'techer'] 
        >>> d = dict(zip(k,v)) 
        >>> d {'name': 'gaoqi', 'age': 18, 'job': 'techer'}
    
    3. 通过 fromkeys 创建值为空的字典 
        >>> a = dict.fromkeys(['name','age','job']) 
        >>> a {'name': None, 'age': None, 'job': None}
        
'''

#字典元素的访问
'''
    1. 通过 [键] 获得“值”         a['name']
    2. 通过 get()方法获得“值”。    a.get('name')
    3. 列出所有的键值对            a.items()
    4. 列出所有的键，列出所有的值    a.keys() a.values()
'''

#字典元素添加、修改、删除
'''
    1. 给字典新增“键值对”。
        如果“键”已经存在，则覆盖旧的键值对；
        如果“键”不存在， 则新增“键值对”
        
    2. 使用 update()将新字典中所有键值对全部添加到旧字典对象上。
        如果 key 有重复，则直接覆盖。   
        
    3. 字典中元素的删除，
        可以使用 del()方法；      del(a['name'])
        clear()删除所有键值对；
        pop()删除指定键值对，并返回对应的“值对象”；   b = a.pop('age')

'''

#表格数据使用字典和列表存储，并实现访问
'''
    r1 = {"name":"高小一","age":18,"salary":30000,"city":"北京"} 
    r2 = {"name":"高小二","age":19,"salary":20000,"city":"上海"} 
    r3 = {"name":"高小五","age":20,"salary":10000,"city":"深圳"} 
    tb = [r1,r2,r3] 
    
    #获得第二行的人的薪资 
        print(tb[1].get("salary"))
    
    #打印表中所有的的薪资 
    for i in range(len(tb)):# i -->0,1,2 
        print(tb[i].get("salary"))

'''

#集合创建和删除
'''
    1. 使用{}创建集合对象，并使用 add()方法添加元素
    2. 使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据,则只保留一个
    3. remove()删除指定元素；clear()清空整个集合
'''

#选择结构嵌套
'''
    score = int(input("请输入一个在 0-100 之间的数字：")) 
    grade = "" 
    if score>100 or score<0: 
        score = int(input("输入错误！请重新输入一个在 0-100 之间的数字：")) 
    else:
        if score>=90: 
            grade = "A" 
        elif score>=80: 
            grade = 'B' 
        elif score>=70: 
            grade = 'C' 
        elif score>=60: 
            grade = 'D' 
        else:
            grade = 'E' 
        print("分数为{0},等级为{1}".format(score,grade))
        
    score = int(input("请输入一个在 0-100 之间的数字："))
    degree = "ABCDE"
    num = 0
    if score > 100 or score < 0:
        score = int(input("输入错误！请重新输入一个在 0-100 之间的数字："))
    else:
        num = score//10
        print("分数是{0},等级是{1}".format(score , degree[9-num]))
'''

#while 循环
'''
    num = 0 
    while num<=10: 
        print(num) 
        num += 1
'''

#嵌套循环和综合练习
'''
    for m in range(1,10): 
        for n in range(1,m+1): 
            print("{0}*{1}={2}".format(m,n,(m*n)),end="\t") 
    print()
'''

#break 语句
'''
    while True: 
        a = input("请输入一个字符（输入 Q 或 q 结束）") 
        if a.upper()=='Q': 
            print("循环结束，退出") 
            break 
        else:
            print(a)
'''

#continue 语句
'''
    #要求输入员工的薪资，若薪资小于0则重新输入。
    最后打印出录入员工的数量和薪资明细，以及平均薪资.
    
    empNum = 0 
    salarySum= 0 
    salarys = [] 
    while True: 
        s = input("请输入员工的薪资（按 Q 或 q 结束）") 
        if s.upper()=='Q': 
            print("录入完成，退出") 
            break 
        if float(s)<0: 
            continue 
        empNum +=1 
        salarys.append(float(s)) 
        salarySum += float(s) 
    print("员工数{0}".format(empNum))    
    print("录入薪资：",salarys) 
    print("平均薪资{0}".format(salarySum/empNum))


'''

#else 语句
'''
    员工一共 4 人。录入这 4 位员工的薪资。
    全部录入后，打印提示“您已经全部录入 4 名员工的薪资”。
    最后，打印输出录入的薪资和平均薪资
    
    salarySum= 0 
    salarys = [] 
    for i in range(4): 
        s = input("请输入一共 4 名员工的薪资（按 Q 或 q 中途结束）") 
        if s.upper()=='Q': 
            print("录入完成，退出") 
            break 
        if float(s)<0: 
            continue 
        salarys.append(float(s)) 
        salarySum += float(s) 
    else:
        print("您已经全部录入 4 名员工的薪资") 
        print("录入薪资：",salarys) 
        print("平均薪资{0}".format(salarySum/4))


'''