Python学习之旅--容器

1,字符串
  • 目的: 知道字符串的格式

  • 操作流程:

    • 三种格式

      # 1, 字符串,单引号形式
      name = '张三'
      print(type(name))
      
      # 2, 字符串, 双引号的形式
      product = "UiBot"
      print(type(product))
      
      # 3,字符串, 三引号形式
      company = """赵jc123213..."""
      print(type(company))
      
2,输入输出
  • 目的: 知道字符串的输出形式, 和输入格式

  • 操作流程:

    # 1, 字符串, 格式化输出一
    name = "迪丽热巴"
    age = 23
    print("她的名字是%s, %d岁了"%(name,age))
    
    # 2, 字符串, 格式化输出二, f-string
    print(f'她的名字是:{name}, {age}岁了')
    
    # 3, 字符串, 格式化输出三, format
    print("她弟名字是:{}, {}岁了".format(name,age))
    
    print("====================华丽分割线======================")
    
    # 4,字符串输入
    product = input("请输入你要学习的内容:")
    print("学习的是 = {}".format(product))
    
3,切片
  • 目的: 可以通过切片方法, 截取字符串内容

  • 操作流程:

    """
    格式:
        name[start:end:step]
        start: 开始位置的索引(包含),默认值0
        end: 结束位置索引(不包含),默认值字符串长度
        step: 步长,默认1
    """
    name = "helloworld"
    print(name[0:10:1]) # helloworld, 里面默认值
    print(name[::]) # helloworld, 和上面等价
    
    # 1, 截取name中的hello
    print(name[0:5:])
    
    # 2, 截取name中的world
    print(name[5::])
    
    # 3,截取name中的llo
    print(name[2:5:])
    
    # 4,获取name中的指定位置的字符串
    print([name[::2]])
    
    # 5,面试题: 使用切片的方式将字符串进行反转 
    print(name[::-1]) # 等价于 name[-1:-len(name)-1:-1]
    
4, 字符串方法
  • 目的: 了解python中常见的字符串方法

  • 操作流程:

    • 需要掌握的: +连接的, 获取值的, lower,upper,split
    #1,字符串连接操作 +
    print("hello" + "world")
    print(3*"hello" + "world")
    name = "hello"
    print(name + "zjc")
    
    #2,获取字符串中的字符, 格式, 字符串[索引]
    print(name[0])
    print(name[1])
    
    #3,capitalize,首个字符大写,其余为小写
    print("hello world".capitalize()) # Hello world
    
    #4,casefold, 大写转小写,支持德语
    print("hello WorlD".casefold()) #hello world
    
    #5,center, 当指定长度大于字符串长度,两边补空格
    print("zjc".center(10))
    
    #6,count,指定字符在指定位置出现的次数
    print("helloworld".count("l",0,6))
    
    #7,endswith, 判断字符是否已指定的字符串结尾
    print("加藤.avi".endswith(".avi"))
    
    #8,find,查找字符串位置,不存在返回-1
    print("helloworld".find("lloa"))
    
    #9,format_map,格式化输出对象
    class Default(dict):
        def __missing__(self, key):
            return "荷兰"
    print('{name} was born in {country}'.format_map(Default(name='Guido')))
    
    #10,index,查找字符串位置,不存在报错
    # print("helloworld".index("lloa"))
    
    #11, isspace,判断字符串是不是只有空白
    print("   a".isspace())
    
    #12,join, 将列表连接成一个字符串
    print("---".join(["A","B","C"])) # A---B---C
    
    #13,lower,将字符串全部转小写
    print("HELLOzjcPython".lower())
    
    #14,lstrip
    print('aaa.example.com'.lstrip('cmowza.'))
    
    #15,partition, 使用指定的符号将字符串切割成三部分
    print("hello,world,python,zjc".partition(","))
    
    #16,split, 使用指定的符号将字符串切割成若干块
    print("hello,world,python,zjc".split(","))
    
    • 官方字符串方法: https://docs.python.org/zh-cn/3.8/library/stdtypes.html#string-methods
5, 列表
  • 目的: 知道列表的格式, 遍历方式

  • 作用: 用来存储多个元素的容器

  • 操作流程:

    #1, 定义列表
    names = ["迪丽热巴","古力娜扎","马尔扎哈",100]
    print(names)
    
    #2,获取列表的值, 列表名称[索引]
    # 索引取值: [0, 列表长度-1], 如果超出报错
    print(names[0])
    print(names[1])
    print(names[2])
    print(names[3])
    print("================")
    
    #3,遍历列表
    for i in range(0,len(names)):
        print(names[i])
    
    #4,获取列表长度,方法
    print(len(names))
    
6, 列表方法
  • 目的: 掌握列表中常见的操作方法

  • 操作流程

    #1,添加元素,append, extend, insert
    names = ["迪丽热巴","古力娜扎","马尔扎哈"]
    names.append("刷我滴卡")
    names.extend(["A","B"]) # names += ["A","B"]
    names.insert(1,"鹿晗")
    print(names)
    
    #2,修改元素
    names[0] = "热巴"
    print(names)
    
    #3,查找 in, not in(Boolean), index, count
    print("鹿晗" not in names)
    print(names.index("A"))
    print(names.count("A"))
    
    #4,删除 del, pop, remove
    # del names[0] #删除之后,没有返回值
    # print(names.pop(0))# 删除之后,有返回值, 根据索引来删除的
    names.remove("鹿晗")# 删除之后,没有返回值, 根据元素来删除的
    print(names)
    
    #5,列表反转
    temp = [1,2,3,4,5]
    temp.reverse()
    print(temp)
    
7, 列表嵌套
  • 目的: 了解列表的嵌套方式, 以及遍历过程

  • 操作流程

    #1,列表嵌套
    # man_names = ["王宝强","徐峥","黄渤"]
    # woman_names = ["迪丽热巴","古力娜扎","马尔扎哈"]
    people_names = [["王宝强","徐峥","黄渤"],["迪丽热巴","古力娜扎","马尔扎哈"]]
    
    #2,遍历
    for item in people_names:
        for name in item:
            print(name)
    
8, 元祖
  • 目的: 知道元祖的定义格式,取值方式,遍历

  • 操作流程

    """
    元祖特点:
        1, 数据不允许修改, 添加
        2, 配合字典使用作为key
        3, 当一组数据定义好之后,不允许别人修改,可以使用元素
    """
    
    #1, 定义元素
    names = ("迪丽热巴","古力娜扎","马尔扎哈")
    print(names[0])
    print(len(names))
    
    #2,遍历, 和列表完全一样
    for i in names:
        print(i)
    
9, 字典
  • 目的: 掌握字典的作用, 定义方式, 取值方式

  • 操作流程

    """
    字典作用:
        用来详细的描述一件事物
    
    字典定义格式:
        {key: value, key2:value2}
    
    字典取值:
        字典名[key]
    """
    
    #1,定义字典
    person = {
        "姓名":"迪丽热巴",
        "身高":"167cm",
        "体重":50,
        "公司":"TVB"
    }
    print(person)
    
    #2,获取字典元素
    print(person["身高"])
    
    #3,遍历,获取到的是key, 需要用key来取值
    for key in person:
        print(f"key = {key}, value = {person[key]}")
    
    
10,字典方法
  • 目的: 掌握字典中的常见增删改查方法

  • 操作流程

    #1, 定义字典, 添加元素
    person = {
        "姓名":"迪丽热巴",
        "身高":"167cm",
        "体重":50,
        "公司":"TVB"
    }
    person["性别"] = "女"
    # print(person)
    
    #2,修改
    person["性别"] = "woman"
    # print(person)
    
    #3,删除
    del person["性别"]
    print(person)
    
    #4,查, in ,not in
    # print("公司" in person)
    
    #5,额外方法
    #5,1 获取字典中所有的key
    print(person.keys())
    
    #5,2 获取字典中所有的value
    print(person.values())
    
    #5,3 将元素转换成元祖
    print(person.items())
    
    #5,4 遍历
    for key,value in person.items():
        # print(f"{key},{person[key]}")
        # print(key)
        print(f"key = {key}, value = {value}")
    
11,通用方法
  • 目的: 掌握python中内置的常见通用方法

  • 操作流程:

    #1, 列表相加
    print([1, 2] + [3, 4] * 2)
    
    #2, len
    print(len([1,2,3]))
    print(len((1,2,3)))
    print(len({"name":"张三","age":13}))
    
    #3, max,min
    print(max([4,5,6,6,2,2,34,1]))
    print(min([4,5,6,6,2,2,34,1]))
    
    #4,del 删除的是字典列表
    a = (1,2,3) #不能删除
    b = [1,2,3]
    c = {"a":1,"b":2}
    del c["a"]
    print("=========================")
    
    """
    5,练习,需求: 通过a-z,A-Z,0-9随机生成一个32位的随机字符串
    应用场景: 加密过程中用到的字符串, sha1
    """
    import string
    import random
    # print(string.ascii_letters) # 52个大小写字符
    # print(string.digits) # 0123456789十个数字
    base_string = string.ascii_letters + string.digits
    random_list = random.choices(base_string,k=32)# 根据提供的字符串,随机获取32位
    random_string = "".join(random_list)
    print(random_string)
    
    
12, lambda
  • 目的: 知道什么是lambda表达式, 以及他的作用

  • 操作流程:

    """
    lambda表达式格式(匿名函数):
        lambda 参数1,参数2: 代码
        
    注意点:
        1, 参数不能写类型
        2, 代码里面不能写复杂逻辑,比如return, for, if
        3, lambda表达式定义后之后,需要马上执行
        
    作用:
        1, 通过lambda表达式可以快速去执行一段逻辑
        2, 可以当成参数进行传递
    """""
    
    #1, 无参数,无返回值
    (lambda : print("这是一个神奇的函数"))()
    
    #2, 无参数,有返回值
    a = (lambda : 10 + 20)()
    # print(a)
    
    #3, 有参数,无返回值
    (lambda num1,num2: print("num1 = {},num2={}".format(num1,num2)))(5,15)
    
    #4, 有参数,有返回值
    b = (lambda num1,num2: num1 * num2)(4,6)
    print(b)
    print("========================")
    
    def login(check):
        result = check("zhangsan","123456")
        return result
    
    result = login(lambda username,passsword: username + "," +  passsword)
    print(result)
    
13, 推导式
  • 目的: 可以通过推导式遍历列表,元祖,字典, 并且可以通过字典推导式创建字典

  • 操作流程:

    #1, "列表"推导式: 快速遍历列表,元祖,字典的
    # names = ["张三","李四","王五"]
    # names2 = ("张三","李四","王五")
    # [print(name) for name in names]
    # [print(name) for name in names2]
    # person = {
    #     "姓名":"迪丽热巴",
    #     "年龄":13,
    #     "性别":"女"
    # }
    # [print(f"{p}, {v}") for p,v in person.items()]
    
    #2, 字典推导式, 可以根据两个列表快速构建出一个字典来
    names = ["迪丽热巴","古力娜扎","马尔扎哈"]
    starts = ["天蝎座","狮子座","处女座"]
    dict = {key:value for key,value in zip(names,starts)} # zip(names,starts) => ((迪丽热巴,天蝎座),(古力娜扎,狮子座))
    print(dict)
    
14, 集合
  • 目的: 可以通过集合求出列表的交集,并集,补集

  • 操作流程

    """
    集合格式:
        {value1, value2, value3,...}
    """
    
    #1, 定义列表,转换成集合
    names = [1,2,3]
    ages = [2,3,4]
    x_names = set(names)
    x_ages = set(ages)
    
    #2,求出集合的交集
    x_result = x_names & x_ages
    print("集合的交集 = {}".format(x_result))
    
    #3,求出集合的并集
    y_result = x_names | x_ages
    print("集合的并集 = {}".format(y_result))
    
    #4,求出集合的差集
    z_result = x_names - x_ages
    print("集合的差集 = {}".format(z_result))
    
    #5,将集合转换列表
    print(list(z_result))
    print(type(list(z_result)))
    
    
  • 注意点:

    • set集合可以自动去重
    • 添加的元素无序
15, 容器转换
  • 目的: 可以实现list,tuple,set之间的相互转换

  • 操作流程

    #1, list->tuple,set
    a = [1,2,3]
    a_tuple = tuple(a)
    a_set = set(a)
    # print(a_tuple)
    # print(a_set)
    
    #2,tuple->list,set
    b = [4,5,6]
    b_list = list(b)
    b_set = set(b)
    # print(b_list)
    # print(b_set)
    
    #3,set->tuple,list
    c = set()
    c.add("A")
    c.add("B")
    c.add("B")
    c.add("C")
    c_list = list(c)
    c_tuple = tuple(c)
    print(c_list)
    print(c_tuple)
    

总结

1, 字符串, 格式’’, “”, “”" “”"

2, 输入,输出; input, print, f’{},{}’, format

3, 切片, name[start,end,step]; 包头不包位; 反转面试题; name[::-1]

4, 字符串常见方法, +, name[索引], lower, upper, find, index

5, 列表方法, [], append, extend, insert, del, pop, remove, reserve

6, 元素, (), 特点: 数据不能改变

7, 字典, {key:value}, 特点: 键值对, del, keys(), values(), items()

8, len, max, min, string.ascii_letters, digits, random.choice(base_string,k=32)

9, lambda,匿名函数,快速执行逻辑,还需要当成参数传递

10, 推导式,列表,字典

11, 集合,容器,方便对数据进行差集,并集,交集获取

12, 容器转换,set,list,tuple

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值