DMOZ中文网站分类目录-免费收录各类优秀网站的中文网站目录.
  • DmozDir.org
DMOZ目录快速登录入口-免费收录各类优秀网站的中文网站目录.由人工编辑,并提供网站分类目录检索及地区分类目录检索,是站长免费推广网站的有力平台!

【详细】Python基础(一)

  • 【详细】Python基础(一)

  • 已被浏览: 33 次2021年01月14日    来源:  https://www.cnblogs.com/cyouagain/p/14275431.html
  • @目录前言1. Python环境的搭建1.1 python解释器的安装1.2 pycharm的安装2. Python基础语法2.1 基本语法2.2 数据类型2.3 标识符与关键字2.4 格式化输出2.5 转义字符和print的结束符2.6

    @

    目录
    • 前言
    • 1. Python环境的搭建
      • 1.1 python解释器的安装
      • 1.2 pycharm的安装
    • 2. Python基础语法
      • 2.1 基本语法
      • 2.2 数据类型
      • 2.3 标识符与关键字
      • 2.4 格式化输出
      • 2.5 转义字符和print的结束符
      • 2.6 输入与数据类型转换
      • 2.7 复合赋值运算符和逻辑运算符
    • 3. Python常用语句
      • 3.1 判断语句(if语句、if-else语句、if-elif语句)
      • 3.2 判断语句(if嵌套)
      • 3.3 判断语句(if 综合案例)
      • 3.4 循环语句(while循环)
      • 3.5 循环语句(while循环嵌套)
      • 3.6 循环语句(while...else)
      • 3.7 循环语句(for、for...else)
    • 4. 字符串
      • 4.1 字符串的使用
      • 4.2 下标和切片
      • 4.3 字符串常用操作方法(查找、修改、判断)
    • 5. 列表、元组
      • 5.1 列表的创建和使用
      • 5.2 判断数据是否在列表中存在
      • 5.3 列表的常见操作(查找、增加、删除、修改、赋值)
      • 5.4 列表的循环遍历(for、while)
      • 5.5 列表的嵌套
      • 5.6 元组的访问
      • 5.7 元组常见操作(查找、修改)
    • 6. 字典、集合
      • 6.1 字典的创建
      • 6.2 字典常用操作(增、删、改、查)
      • 6.3 字典的遍历
      • 6.4 字典小总结
      • 6.5 集合的创建
      • 6.6 集合常见操作(增、删、查)
      • 6.7 集合小总结

    前言

    人生苦短,我用Python
     
    Python基础(二): https://blog.csdn.net/weixin_46818279/article/details/108855481
     
     
     

    1. Python环境的搭建

    解释器和开发集成环境pycharm的安装还是比较简单的。
     
     

    1.1 python解释器的安装

     
    (1) 到官网下载python解释器

    下载地址:https://www.python.org/downloads/release/python-372/

    在这里插入图片描述
    注释: 这个解释器是3.7.2版本的
     
     
    (2) 开始安装python解释器

    安装解释器非常简单,一定要把把下面的环境变量打上对勾, 然后在上面选择Install Now。 这里我选择Install Now,默认安装在C盘。如下如所示

    在这里插入图片描述
     
    (3) 检验python解释器是否安装成功

    在dos命令行下,输入python,如果出现版本号,则安装成功。

    在这里插入图片描述
     
     
     

    1.2 pycharm的安装

     
    工欲善其事,必先利其器。Pycharm是一种Python IDE(集成开发环境),带有一整套可以帮助用户在使用Python语言时 提高其效率的工具。 简单的说提高你写代码的速度,编写代码更爽更舒服。
     

    (1) 官网下载Pycharm

    下载地址:http://www.jetbrains.com/pycharm/download/#section=windows

    在这里插入图片描述
     

    小提示: Pythoncharm分为专业版(professional)和社区版(community)。专业版集成了一些框架和库,收费的,基础里用不到,社区版就够用了。
     
     
    (2) 开始安装pycharm

    安装pycharm也非常简单,选好安装路径,我安装到D盘了。然后到达了如下图的界面,选择一个64位的桌面图标(shortcut),再选择一个.py的联想,如下图所示。

    在这里插入图片描述
    在这里插入图片描述
     

    (3) 在pycharm里新建一个项目

    第一次在pycharm中新建项目的时候,你点New Project会到达如下图的界面。需要添加解释器,就是添加你安装解释器的路径,如下图所示:

    在这里插入图片描述
     
    小提示: python解释器添加完,项目创建好了之后,就可以愉快的写代码了。pycharm里面的快捷键,还有字体的修改,解释器的修改等等,可以百度自行搜索。

     
     
     

    2. Python基础语法

     

    2.1 基本语法

     
    直接上代码,一看就懂了

    # 这是一个输出语句
    print("Hello,World")
    """
    这是一个多行注释
    """
    
    """
    这也是一个多行注释
    """
    ====================================================================================
    # 定义变量,储存数据TOM
    my_name = "TOM"
    print(my_name)
    
    # 定义变量,储存数据,这是一瓶冰红茶
    icdTea = "这是一瓶冰红茶"
    print(icdTea)
    
    

     

    2.2 数据类型

     
    来一个思维导图,简单明了

    在这里插入图片描述
    直接上代码,一看就懂了

    # 整型和浮点型
    num1 = 1
    num2 = 1.2
    print(type(num1))
    print(type(num2))
    
    # 这是一个字符串类型
    a = "hello,world!"
    print(type(a))
    
    # 这是一个布尔类型
    b = True
    print(type(b))
    
    # 这是一个列表类型
    c = [10,20,30]
    print(type(c))
    
    # 这是一个元组类型
    d = (10,20,30)
    print(type(d))
    
    # 这是一个集合
    e = {10,20,30}
    print(type(e))
    
    # 这是一个字典
    f = {"name": "TOM","age": 18}
    print(type(f))
    
    

    小提示:还有个复数类型,就是用于表示数学中的复数,用 real + imagej表示
     
     

    2.3 标识符与关键字

     
    这里不多说,跟C语言和Java中的知识都差不多一样,提几个需要注意的地方。
    标识符:
    (1)由数字、字母、下划线组成
    (2)不能数字开头
    (3)不能使用内置关键字
    (4)严格区分大小写
     
     

    2.4 格式化输出

     
    直接上代码,一看就懂

    age = 18
    name = "TOM"
    weight = 75.5
    stu_id = 1
    
    print("今年我的年龄是%d" % age)
    print("我的名字叫%s" % name)
    print("我的体重是%.3f" % weight)
    print("我的体重是%03d" % stu_id)  # 不够三位,用0补全
    
    print("我的名字叫:%s ,我的年龄是:%d" % (name,age))
    print("我的名字叫:%s,我的年龄是:%d" % (name,age+1))  # 年龄加一岁
    
    print("我的名字叫:%s,今年的年龄是:%d,我的体重是:%s,我的学号是:%03d" % (name,age,weight,stu_id))
    
    ===========================================================================================
    
    name = "TOM"
    age = 18
    weight = 75.5
    
    # %s比较强大
    print("我的名字叫:%s,我的年龄是:%s,我的体重是:%s" % (name,age,weight))
    
    ===========================================================================================
    
    name = "TOM"
    age = 16
    
    # 语法:f"{表达式}"
    # 这样的输出格式更加高效和简洁
    
    print(f"我的名字叫{name},我的年龄为{age}")
    
    

    小提示:

    (1)务必掌握这种输出格式f"{表达式}" ,这种的输出格式更加高效简洁。f-格式化字符串是Python3.6中新增的格式化方法,这种方法更简单易读。

    (2)常见的格式符号:%s (字符串) %d(有符号的十进制整数) %f(浮点数) %c(字符) 这几种是常见的格式符号,如果需要其他的再去查就好了。
     
     

    2.5 转义字符和print的结束符

     
    直接上代码,一看就懂
     

    print("hello world")
    print("hello\nworld")  # hello world直接换行输出
    print("\thello")    # 前面输出空格再输出hello
    
    =================================================================
    
    # 在python中,print()默认自带end="\n"这个换行结束符,用户可以按照需求更改结束符
    
    print("hello", end="\n")
    print("world")
    
    print("hello", end="\t")
    print("hello")
    
    print("hello", end="...")
    print("world")
    
    

    小提示:要记住print的结束符这个小知识点。
     
     

    2.6 输入与数据类型转换

     
    直接上代码,一看就懂
     

    passward = input("请输入您的密码:")
    print(f"您输入的密码是:{passward}")
    
    # input接收到的数据类型都是字符串
    print(type(passward))
    
    ====================================================================================
    
    num = input("请输入一个数字:")
    print(num)
    print(type(num))
    
    # 强制转换为int类型
    print(type(int(num)))
    print(type(int(num)))
    
    ===================================================================================
    
    """
    因为得到数据类型并不是程序想要的数据类型,这个时候需要借助数据类型转换的函数来转换
    """
    num = 1
    str1 = "10"
    
    # 1.将数据转换成浮点类型 float()
    print(type(float(num)))
    print(float(num))
    print(float(str1))
    
    # 2. 将数据转换成字符串型 str()
    print(type(str(num)))
    
    # 3. 序列转换成元组 tuple()
    list1 = [10,20]
    print(type(list1))
    print(type(tuple(list1)))
    print(tuple(list1))  	 # (100, 200)
    
    # 4. 将一个元组转换成序列 list()
    t1 = (100,200)
    print(list(t1)) 		# [100, 200]
    
    # 5. eval() 计算在字符串中的有效Python表达式,并返回一个表达式。把字符串中的数据转换成他原本的类型
    str3 = "1"
    str4 = "2.1"
    str5 = "(10,20)"
    str6 = "[10,20]"
    print(type(eval(str3)))   # <class "int">
    
    

     
     

    2.7 复合赋值运算符和逻辑运算符

     
    总结几个常用算数运算符
     
    (1)**      返回a的b次幂,比如 2 ** 3,结果位8

    (2)%      取余

    (3)//      取整除,返回商的整数部分。
     
    总结几个常用复合赋值运算符
     
    直接上代码,一看就懂
     

    a = 10
    a += 1
    print(a)  # 11
    
    b = 10
    b *= 3
    print(b)  # 30
    
    # 注意:先算复合赋值运算符右侧的表达式,算复合赋值运算
    c = 10
    c += 1 + 2
    print(c)  # 13
    
    # 测试
    d = 10
    d *= 1 + 2
    print(d)  	# 30 说明先算复合赋值运算符右侧的表达式,再算复合赋值运算
    
    =====================================================================
    
    # 逻辑运算符的运用
    
    a = 0
    b = 1
    c = 2
    
    # 1.and
    print((a < b) and (a < c))   # True
    print(a > b and a < c)		# False
    
    # 2.or
    print(b > c or a < c)  # True
    
    # 3.not
    print(not a < b)	# False
    
    # 程序员的习惯
    # 加小括号为了避免歧义,增加优先级
    

     
     

    3. Python常用语句

    3.1 判断语句(if语句、if-else语句、if-elif语句)

    直接上代码,一看就懂

    if True:
        print("条件成立了")
    # 下面的代码没有缩进到if语句块,所以和if条件无关
    print("这个代码执行吗?")
    
    =================================================================
    
    age = 20
    if age >= 18:
        print("已经成年可以上网")
    
    # 注意:不缩进的语句,跟if语句没有关系了。
    print("系统关闭")
    
    ================================================================
    
    # 注意:input接受用户输入的数据是字符串类型,这时需要转换为int类型才能进行判断
    age =int( input("请输入您的年龄:"))
    if age >= 18:
        print(f"您输入的年龄是{age},已经成年可以上网")
        
    ================================================================
    
    age =int( input("请输入您的年龄:"))
    if age >= 18:
        print(f"您输入的年龄是{age},已经成年可以上网")
    else:
        print(f"你输入的年龄是{age},小朋友,回家写作业去")
    
    ----------------------------------------------------------------
    
    age = int(input("请输入您的年龄"))
    if age < 18:
        print(f"您输入的年龄是{age},童工")
    elif (age >= 18) and (age <= 60):
        print(f"您输入的年龄是{age},合法")
    elif age > 60:
        print(f"您输入的年龄是{age},退休")
    
    -----------------------------------------------------------------
    
    age = int(input("请输入您的年龄"))
    if age < 18:
        print(f"您输入的年龄是{age},童工")
    #  条件的简化写法
    elif 18 <= age <= 60:
        print(f"您输入的年龄是{age},合法")
    elif age > 60:
        print(f"您输入的年龄是{age},退休")
    
    

     

    3.2 判断语句(if嵌套)

    直接上代码

    # if嵌套坐公交
    
    money = 1
    seat = 1
    
    if money == 1:
        print("土豪,请上车")
        # 判断是否能坐下
        if seat == 1:
            print("有空做,请坐下")
        else:
            print("没有空做,请等着....")
    else:
        print("没钱,不让上车")
    
    
    

     

    3.3 判断语句(if 综合案例)

     
    直接上代码

    # 猜拳游戏
    import random
    
    player = int(input("请出拳:0--石头;1--剪刀;2--布"))
    # computer = 1
    computer = random.randint(0,2)
    if ((player == 0) and (computer == 1)) or ((player == 1) and (computer == 2)) or ((player == 2) and (computer == 0)):
        print("玩家获胜,哈哈哈 ")
    elif player == computer:
        print("平局")
    else:
        print("电脑获胜")
    
    ================================================================================
    
    # 随机数的使用
    
    """
    步骤:
        1.导入模块
        import random
        2.使用这个模块中的功能
        random.randint
    """
    import random
    num = random.randint(0,2)
    print(num)
    
    ================================================================================
    
    # 三目运算符
    a = 1
    b = 2
    c = a if a > b else b
    print(c)
    
    aa = 10
    bb = 6
    cc = aa - bb if aa > bb else bb - aa
    print(cc)
    
        
    

     

    3.4 循环语句(while循环)

    直接看个栗子就能上手使用while循环

    # 1-100 累加和
    i = 1
    result = 0
    while i <= 100:
        result += i
        i += 1
    
    print(result)
    

     

    3.5 循环语句(while循环嵌套)

    
    # 重复打印5行星星
    
    j = 0
    while j < 5:
        # 一行星星的打印
        i = 0
        while i < 5:
            # 一行内的星星不能换行,取消print默认结束符\n
            print("*", end="")
            i += 1
        # 利用空的print来进行换行
        print()
        j += 1
    
    ============================================================
    
    # 打印三角形,每行星星的个数和行号数相等
    # j表示行号
    j = 0
    while j < 5:
        # 一行星星的打印
        i = 0
        while i <= j:
            # i表示每行里面星星的个数,这个数字要和行号相等所以i要和j联动
            print("*", end="")
            i += 1
        # 利用空的print来进行换行
        print()
        j += 1
    
    =============================================================
    
    j = 1
    while j <= 9:
        # 一行表达式的开始
        i = 1
        while i <= j:
            print(f"{i} * {j} = {i*j} " , end="\t")
            i += 1
        # 一行表达式的结束
        print()  # 自带换行符
        j += 1
        
    

     

    3.6 循环语句(while...else)

    
    """
    所谓else指的是循环正常结束之后要执行的代码,
    即如果是break终止循环的情况,else下方缩进的代码将不执行。
    """
    
    i = 1
    while i <= 5:
        if i == 3:
            break
        print("媳妇我错了")
        i += 1
    else:
        print("媳妇原谅我了,真开心呐")
    
    ===================================================================
    
    """
    因为continue是退出了当前一次循环,继续下一次循环,所以改循环在continue控制下
    是可以正常结束的,当循环结束后,则执行了else缩进的代码。
    """
    i = 1
    while i <= 5:
        if i == 3:
            # 切记在执行continue之前,一定要改变计数器。否则就会陷入死循环
            i += 1
            continue
        print("媳妇我错了")
        i += 1
    else:
        print("媳妇原谅我了,真开心呐")
    
        
    

     

    3.7 循环语句(for、for...else)

    
    str1 = "ilovepython"
    for i in str1:
        # 当某些条件成立,退出循环  条件:i取到字符e的时候退出循环
        if i == "e":
            # continue
            break
        print(i)
       
    ======================================================================
    
    所谓else指的是循环正常结束之后要执行的代码,
    str1 = "ilovepython"
    for i in str1:
        print(i)
    else:
        print("循环正常结束执行的else代码")
        
    

     

    4. 字符串

    4.1 字符串的使用

    # 字符串的使用区别
    
    a = "hello" \
        " world"
    print(a)   # 输出一行 hello world
    
    c = """hello 
    world"""
    print(type(c))
    print(c)       # 换行输出hello world
    
    
    d = """hello 
    world"""
    print(type(d))  # <class "str">
    print(d)        # 会直接换行输出
    
    # 打印 I"m Tom,使用单引号,必须使用转移字符,把他转义过去
    e = "I\"m Tom"
    print(e)
    
    # 要是有单引号出现可以使用双引号括住
    f = "I" love Tom"
    print(f)
    
    ============================================================================
    
    # 字符串的输出 
    
    name = "Tom"
    print("我的名字是%s" % name)
    print(f"我的名字是{name}")
    
    ==============================================================================
    
    # 字符串的输入
    password = input("请输入您的密码")
    print(f"您输入的密码是{password}")
    # input接收到的用户输入的数据都是字符串
    print(type(password))
    
    

     

    4.2 下标和切片

     
    (1)下标

    str1 = "abcdefg"
    print(str1)
    # 数据在运行过程中存储在内存
    # 使用字符串中特定的数据
    # 使用编号精确找到某个字符数据,下标索引值
    # str[下标]
    print(str1[0])  # 输出a
    print(str1[1])  # 输出b
    
    

     
    (2)切片

    # 序列名[开始位置的下标:结束位置的下表:步长]
    # 取值区间左闭右开的
    
    str1 = "012345678"
    # print(str1[2:5:1]) 234
    # print(str1[2:5:2]) 24
    # print(str1[2:5]) 234  # 如果不写步长,默认步长是1
    # print(str1[:5]) 01234   # 如果不写开始,默认从0开始选取
    # print(str1[2:]) 2345678 # 如果不写结束,表示选取到最后
    # print(str1[:]) 012345678  # 如果不写开始和结束,表示选取所有
    
    # 负数测试
    # print(str1[::-1]) 876543210 # 如果步长为负数,表示倒叙选取
    # print(str1[-4:-1])  567    下标为-1表示最后一个数据,依次向前类推
    
    # 终极测试
    # print(str1[-4:-1:1]) 567
    print(str1[-4:-1:-1]) # 不能选取出数据:从-4开始到-1结束,选取方向从左到右,但是-1步长:从右向左选取
    # 如果选取方向(下标开始到结束的方向)和步长方向冲突,则无法选取数据
    print(str1[-1:-4:-1]) # 876 方向一致就可以正确输出
    
    

    小总结: 下标是精确的找到某一个元素,切片可以利用下标找到某一部分元素(左闭右开)
      
     

    4.3 字符串常用操作方法(查找、修改、判断)

     
    (1)查找

    mystr = "hello world and itcast and itsmail and Python"
    
    # 1. find()
    print(mystr.find("and")) # 输出的是12,以为下标是从0开始数的
    print(mystr.fing("and",15,30))
    print(mystr.find("ands")) # -1,ands字串不存在
    
    # 2. index
    print(mystr.find("and")) # 12
    print(mystr.find("and",15,30)) #23
    print(mystr.index("ands")) #如果index查找字串不存在,报错
    
    # 3. count()
    print(mystr.count("and")) 3
    print(mystr.count("and",15,30)) 1
    print(mystr.count("ands")) 0
    
    # 4. rfind()
    print(mystr.rfind("and")) 35
    print(mystr.find("ands")) -1 如果没找到,则返回-1
    
    # 5. rindex()
    print(mystr.rindex("and")) 35  就算是到着找,它的下标还是从左到右从下标0开始的
    print(mystr.rindex("ands"))
    
    

     
    (2)修改

    # 遇到列表、字典,内部的数据可以直接修改,修改的就是原列表或者原字典。叫做可变类型。
    # 字符串是一个不可变类型的数据
    
    mystr = "hello world and itcast and itheima and Python"
    # replace() 把and换成he replace函数有返回值,返回值是修改后的字符串
    new_str = mystr.replace("and","he")
    # new_str = mystr.replace("and","he",1)
    # 替换次数如果超出字串出席那的次数,表示替换所有这个字串
    # new_str = mystr.replace("and","he",10)
    print(mystr)
    print(new_str)
    
    # 调用了replace函数后,发现原有字符串的数据并没有做到修改,修改后的数据是replace函数的返回值
    # 说明字符串是不可变数据类型
    # 数据是否可以改变划分为 可变类型,不可变类型
    
    # 2. split()  分割,返回一个列表,丢失分割字符
    list1 = mystr.split("and")
    print(list1)
    
    # 3. join() 合并列表里面的字符串数据为一个大字符串
    mylist = ["aa","bb","cc"]
    new_str = "...".join(mylist)
    print(new_str)
    

     
    修改-非重点

    # 一、字符串对齐
    # mystr.ljust(10) 左对齐
    # mystr.rjust(10) 右对齐
    # mystr.rjust(10,".") 以点作为填充效果
    # mystr.center(10) 中间居中
    # mystr.center(10,".") 以点填充空白的地方
    
    
    
    # 二、大小写转换
    mystr = "hello world and itcast and itheima and Python"
    # 1. capitalize() 字符串首字母大写
    # new_str = mystr.capitalize()
    # print(new_str)
    
    # 2. title():字符串中每个单词首字母大写
    # new_str = mystr.title()
    # print(new_str)
    
    # 3. upper():小写转大写
    # new_str = mystr.upper()
    # print(new_str)
    
    # 4. lower():大写转小写
    # new_str = mystr.lower()
    # print(new_str)
    
    
    # 三、删除空白字符
    str1 = "      hello world and itcast and itheima and Python  "
    # 1. lstrip():删除字符串左侧空白字符
    # print(str1)
    # new_str = str1.lstrip()
    # print(new_str)
    
    # 2. rstrip():删除字符串右侧空白字符
    new_str = str1.rstrip()
    print(str1)
    print(new_str)
    
    # 3. strip():删除字符串两侧空白字符
    # new_str = str1.strip()
    # print(new_str)
    
    

     
    (3)判断

    # 判断开头或结尾
    mystr = "hello world and itcast and itheima and Python"
    # 1. startswith(字串,开始位置下标,结束位置下标):判断字符串是否以某个字串开头
    print(mystr.startswith("hello"))
    print(mystr.startswith("hel"))
    print(mystr.startswith("hels"))
    print(mystr.startswith("hell",0,10)) 开始位置下标和结束位置下标可以省略
    
    # 2. endswich(字串,开始位置下标,结束位置下标),始位置下标和结束位置下标可以省略
    print(mystr.endswith("Python"))
    print(mystr.endswith("Pythons"))
    
    # 判断
    3. isalpha():字母  纯字母才可以,如果中间有空格返回的false
    print(mystr.isalpha())
    
    # 4. isdigit():数字,中间也不能有空格,否则返回false
    print(mystr.isdigit())
    mystr1 = "12345"
    print(mystr1.isdigit())
    
    # 5. isalnum():数字或字母或组合
    print(mystr1.isalnum()) # True
    print(mystr.isalnum())  # False 因为中间有空格
    mystr2 = "abc123"
    print(mystr2.isalnum())
    
    # 6. isspace():判断是否是空白,是返回True
    print(mystr.isspace())  # False
    mystr3 = " "
    print(mystr3.isspace())	 # True
    

     

    5. 列表、元组

     

    5.1 列表的创建和使用

    name_list = ["TOM","Lily","ROSE"]
    print(name_list)   # ["TOM", "Lily", "ROSE"]
    # 根据下标进行输出
    print(name_list[0])  # 输出 TOM
    print(name_list[1])  # 输出 Lily
    print(name_list[2])  # 输出 ROSE
    
    

    5.2 判断数据是否在列表中存在

    name_list = ["TOM","Lily","ROSE"]
    # 1. in  如果在里面就返回true,否则false
    print("TOM" in name_list)
    print("TOMS" in name_list)
    
    # 2. not in   这个跟in相反
    print("TOM" not in name_list)
    print("TOMS" not in name_list)
    
    

    体验案例

    name_list = ["TOM","List","ROSE"]
    
    # 需求:注册邮箱,用户输入一个账户名,判断这个账号是否存在,如果存在,提示用户,否则提示可以注册
    name = input("请输入您的邮箱账号名:")
    if name in name_list:
        # 提示用户名已经存在
        print(f"您输入的名字是{name},此用户已经存在")
    else:
        # 提示可以注册
        print(f"您输入的名字是{name},可以注册")
    

     

    5.3 列表的常见操作(查找、增加、删除、修改、赋值)

     
    (1)查找(index、count、len)

    name_list = ["TOM","Lily","Rose"]
    
    # 1.index()
    print(name_list.index("TOM"))  #返回 0
    # print(name_list.index("TOMs"))  没有找到,报错
    
    # 2. count()
    print(name_list.count("TOM"))
    # print(name_list.count("TOMS")) # 报错
    
    # 3.len()
    print(len(name_list)) # 输出3
    

    (2)增加(append、extend、insert)

    # 1. 列表数据是可变的  -- 列表是可变类型
    # 2. append函数追加数据的时候如果是一个序列,追加整个序列到列表的结尾
    
    name_list = ["TOM","Lily","ROSE"]
    name_list.append("xiaoming")
    name_list.append([11,22])
    name_list.append(11)
    print(name_list)  # 输出结果为:["TOM", "Lily", "ROSE", "xiaoming", [11, 22], 11]
    
    # extent() 追加数据是一个序列,把数据序列里面的数据拆开然后逐一追加到列表的结尾
    name_list = ["TOM","Lily","ROSE"]
    name_list.extend("xiaoming")
    # 把序列拆开,逐一的放到列表中
    name_list.extend(["xiaoming","xiaojun"])
    print(name_list) 
     # 输出结果为:["TOM", "Lily", "ROSE", "x", "i", "a", "o", "m", "i", "n", "g", "xiaoming", "xiaojun"]
    
    
    name_list = ["Tom","Lily","ROSE"]
    # name_list.insert(下标,数据)  在指定位置加入数据
    name_list.insert(1,"aa")
    print(name_list) # 输出的结果为:["Tom", "aa", "Lily", "ROSE"]
    
    

    (3)删除(del、pop、remove、clear)

    name_list = ["Tom","Lily","ROSE"]
    
    # 1. del
    # del name_list
    # print(name_list) 已经把列表已经删除,已经没有列表了
    
    # del 也可以指定下标的数据
    # del name_list[0]
    # print(name_list)   # 输出的结果 ["Lily", "ROSE"]
    
    
    # 2. pop() 删除指定下标的数据,如果不指定下标,默认删除最后一个数据
    # 无论是按照下标还是删除最后一个,pop函数都会返回这个被删除的数据. 比较厉害的是删除一个数据能用一个变量去接收
    del_name = name_list.pop()
    del_name = name_list.pop(1)
    print(del_name)
    print(name_list)
    
    # 3. remove(数据) 按照指定的数据进行删除的
    # name_list.remove("ROSE")
    # print(name_list)
    
    # 4. clear() -- 清空
    # name_list.clear()
    # print(name_list)  # 直接清空整个数据
    
    

    (4)修改(reverse、sort)

    name_list = ["TOM","Lily","ROSE"]
    
    # 修改指定下标的数据
    # name_list[0] = "aaa"
    # print(name_list) # ["aaa", "Lily", "ROSE"]
    
    # 2. 逆序 reverse()
    list1 = [1, 3, 4, 2, 5]
    # list1.reverse()
    # print(list1)
    
    # 3. sort() 排序:升序(默认)和 降序
    # list1.sort()  # 升序
    list1.sort(reverse=False)  # 升序 [1, 2, 3, 4, 5]
    list1.sort(reverse=True)   # 降序 [5, 4, 3, 2, 1]
    print(list1)
    
    

    (5)赋值

    name_list = ["tom","lucy","jack"]
    list1 = name_list.copy()
    print(list1)
    print(name_list)
    
    

     

    5.4 列表的循环遍历(for、while)

    for循环

    name_list = ["tom","rose","jack"]
    i = 0
    while i < len(name_list):
        print(name_list[i])
        i += 1
    

    while循环

    # for循环的代码量要少于while的代码量
    # 一般在工作岗位下,涉及到遍历序列当中的数据的话,一般优选于for循环
    name_list = ["tom","rose","jack"]
    for i in name_list:
        # 遍历序列中的数据
        print(i)
        
    

    5.5 列表的嵌套

     
    列表嵌套时的数据查询

    name_list = [["TOM", "Lily","Rose"], ["张三","李四","王二"], [ "小红", "小绿", "小蓝"]]
    # print(name_list)
    # 列表嵌套的时候的数据查询
    print(name_list[0])
    print(name_list[0][0])
    
    

    案例-随机分配办公室

    # 需求:八位老师,3个办公室,将8为老师随机分配到3个办公室
    """
    步骤::
    1.准备数据
        1.1 8位老师 -- 列表
        1.2 3个办公室 -- 列表嵌套
    2. 分配老师到办公室
        随机分配
        就是把老师的名字写入到办公室列表 --办公室列表追加老师数据
    3. 验证是否分配成功
        打印办公室详细信息: 每个办公室的人数和对应的老师名字
    
    """
    import random # 随机模块
    # 1. 准备数据
    teachers = ["A","B","C","D","E","F","G","H"]  # 列表存数据
    offices = [[], [], []]      # 嵌套列表
    
    # 2. 分配老师到办公室 -- 取到每个老师放到办公室列表 -- 遍历老师列表数据
    for name in teachers:
        # 列表追加数据  -- append(整体添加) --extend(拆开添加) --insert(在指定位置加入数据)
        num = random.randint(0,2)
        offices[num].append(name)           #追加数据
    # print(num)
    # print(offices)
    
    # 为了更贴合生活,把各个办公室子列表加一个办公室编号1 ,2 ,3
    i = 1
    # 3. 验证是否成功
    for office in offices:
        # 打印办公室人数 -- 子列表数据的个数 len()
        print(f"办公室{i}的人数是{len(office)}")
        # 打印老师的名字
        # print() -- 每个自立表里面的名字个数不一定 -- 遍历 -- 子列表
        for name in office:
            print(name)
        i += 1
    

     

    5.6 元组的访问

     
    注意: 如果是单个数据的元组,那么后面必须加逗号,否则就不是元组的数据类型,而是整个数据本身的数据类型

    # 输出元组
    t1 = (10, 20, 30)
    print(t1)  # 输出 (10, 20, 30)
    
    # 如果是单个数据的元组,那么后面必须加逗号,否则就不是元组的数据类型,而是整个数据本身的数据类型
    # 1.多个数据元组
    t1 = (10, 20, 30)
    print(type(t1))  # 输出 <class "tuple">
    
    # 2. 单个数据元组
    t2 = (10,)
    print(type(t2))  # 输出 <class "tuple">
    =====================================================================
    
    # 3. 如果单个数据的元组不加逗号
    t3 = (10)
    print(type(t3))  # 输出 <class "int">
    
    t4 = ("aaa")
    print(type(t4))  # 输出 <class "str">
    ================================================================================
    t5 = ("aaa",)
    print(type(t5))  # 输出  <class "tuple">
    

     

    5.7 元组常见操作(查找、修改)

     
    (1)查找

    t1 = ("aa", "bb", "cc")
    
    # 1. 下标
    print(t1[0])   # aa
    
    # 2. index()
    print(t1.index("aa"))  # 输出0  其实有参数二,有参数三对应一个查找的范围,如果没有找到就直接报错。
    
    # 3. count()
    print(t1.count("aa")) # 统计aa的次数,输出结果为1
    
    # 4. len()
    print(len(t1))  # 统计整个元组的个数,输出结果为3
    

     
    (2)修改

    # 元组确实不能修改,但是元组中含有的列表可以修改。
    # 工作中尽可能遵循一个规则,但凡是出现在小括号元组里面的数据,尽可以能靠自觉去要求不做修改
    # 工作中如果是同事的代码,有数据出现在元组中,尽可能在查找操作的时候,小心一点,尽可能不要去修改这一部分的操作。
    
    t1 = ("aa", "bb", "cc")
    # t1[0] = "aaa" 这个操作是错的,是不能修改的。
    t2 = ("aa", "bb", ["cc", "dd"])
    print(t2[2])
    t2[2][0] = "TOM"
    print(t2)
    

     
     

    6. 字典、集合

     

    6.1 字典的创建

    直接上栗子,一看就懂

    """
    字典里面的数据是以键值对形式出现,字典数据和数据顺序没有关系,
    即字典不支持下标,后期无论数据如何变化,只需要按照对应的键的名字来查找数据即可
    """
    
    # 字典特点: 1. 符号为大括号 2. 数据为键值对形式出现  3. 各个键值对之间用逗号隔开
    # 符合上面三个条件就是字典,字典不支持下标。
    # {} 里面放入键值对,用逗号隔开
    
    # 创建有数据的字典
    dict1 = {"name" : "tom", "age" : 18, "gender": "男"}
    # 查看一下dict1的数据类型
    print(type(dict1))   # <class "dict">
    
    # 创建空字典
    dict2 = {}
    print(type(dict2))  # <class "dict">
    
    # 用dict()函数来创建空字典
    dict3 = dict()
    print(type(dict3))
    print(dict3)  # 输出 {}
    
    

     

    6.2 字典常用操作(增、删、改、查)

     
    新增数据

    """
    新增数据的写法:字典序列[key] = 值
     这里的字典为可变类型,打印原字典名,就能看到修改新增之后的数据。之前的元组是不可变类型,是不能修改内部数据的。
    注意: 如果key存在则修改这个key对应的值;如果key不存在则新增此键值对
    """
    
    dict1 = {"name": "TOM" , "age":20 , "gender": "男" }
    
    # name这个键存在这个字典中,所以修改键值对
    dict1["name"] = "ROSE"
    print(dict1)  # 输出修改后的字典 {"name": "ROSE", "age": 20, "gender": "男"}
    
    # id这个key不存在这个字典中,所以新增此键值对
    dict1["id"] = 110
    print(dict1)   # 输出新增后的字典{"name": "TOM", "age": 20, "gender": "男", "id": 110}
    
    

     
     
    删除数据

    dict1 = {"name": "TOM", "age": 20 , "gender": "男"}
    
    # 1.del 删除字典或指定的键值对
    
    # 删除字典
    # del(dict1)
    # print(dict1)   # 报错,说明已经删除了
    
    # 删除指定的字符串
    # del dict1["name"]  # 删除key为name的键值对
    # del dict1["names"]  # 如果删除的内容不存在就会报错
    # print(dict1)		# {"age": 20, "gender": "男"}
    
    # 2. clear() 清空字典
    dict1.clear()
    print(dict1)      # 输出{}
    
    
    

     
     
    修改数据

    dict1 = {"name":"tom", "age":20 , "gender":"男"}
    
    # dict1["name"] = "lily"
    # print(dict1)     # {"name": "lily", "age": 20, "gender": "男"}
    
    dict1["id"] = 2020
    print(dict1)    # {"name": "tom", "age": 20, "gender": "男", "id": 2020}
    

     
     
    查找数据

    # 可迭代的对象指代的是可以用for遍历的对象
    
    dict1 = {"name":"tom", "age": 20 , "gender":"男"}
    
    # 1. [key]
    # print(dict1["name"])    #  输出tom 
    # print(dict1["names"])   # 如果查找的值是不存在的key,则会报错
    
    # 2.函数
    
    # 2.1 get()
    # 语法: 字典序列.get(key,默认值)
    
    # print(dict1.get("name"))   # tom
    # print(dict1.get("names"))  # 如果键值不存在,返回None
    # print(dict1.get("names","不存在")) # 如果键值不存在,返回“不存在”
    
    # 2.2 keys() 查找字典中所有的key,返回可迭代对象
    print(dict1.keys())  # 输出 dict_keys(["name", "age", "gender"])
    
    # 2.3 value() 查找字典中所有的value,返回可迭代对象
    print(dict1.values())  # 输出 dict_values(["tom", 20, "男"])
    
    # 2.4 items() 查找字典中所有的键值对,返回可迭代对象,里面的数据是元组,元组数据1是字典的key,元组数据2是字典key对应的值
    print(dict1.items())  # 输出dict_items([("name", "tom"), ("age", 20), ("gender", "男")])
    
    

     

    6.3 字典的遍历

     

    # key遍历
    
    dict1 = {"name":"tom", "age":20 , "gender": "男"}
    
    for key in dict1.keys():
        print(key)
    """
    输出结果:
           name
           age
           gender
    """    
    
    ==================================================================
    
    # value遍历
    
    dict1 = {"name":"tom", "age":20, "gender":"男"}
    
    for value in dict1.values():
        print(value)
        
    """
    输出结果:
    		tom
    		20
    		男
    """
    =====================================================================
    
    # 键值对遍历
    # dict1.items 可迭代对象的内部是元组
    dict1 = {"name":"tom", "age": 20 , "gender": "男"}
    for item in dict1.items():
        print(item)
    """
    输出结果:
            ("name", "tom")
            ("age", 20)
            ("gender", "男")
    """
    
    =====================================================================
    
    # 键值对拆包遍历
    
    dict1 = {"name":"tom", "age":"20", "gender":"男"}
    
    # xx.items():返回可迭代对象,内部是元组,元组有2个数据
    # 元组数据1是字典的key,元组数据2是字典的value
    
    for key,value in dict1.items():
        # print(key)
        # print(value)
        print(f"{key}={value}")
    
    """
    输出的内容是:
    
        	name=tom
       		age=20
        	gender=男
    """
    

     

    6.4 字典小总结

     

    定义字典
    dict1 = {"name":"TOM", "age":30}
    dict2 = {}
    dict3 = dict()
    
    常见操作
        增/改
    字典序列[key] = 值
    
    查找
        字典序列[key]
        keys()
        values()
        items()
    

    6.5 集合的创建

     
    直接上栗子:

    """
    1 .集合有一个特点:去重,也就是说集合当中的数据是没有重复的,如果有不允许重复的数据出现的时候,这是用用集合存储数据即可。
    2. 创建集合使用{} 或 set();但是如果要创建空集合只能使用set(),因为 {} 用来创建空字典的
    3. 数据的展示循序跟写代码的顺序不一样,集合没有顺序,因为没有顺序,所以不支持下标的操作。
    """
    
    # 1. 创建有数据的集合
    s1 = {10,20,30,40,50}
    print(s1)
    
    s2 = {10,20,30,20,30}
    print(s2)     #{10, 20, 30} 输出结果 因为有去重功能
    
    s3 = set("姓名")
    print(s3)     # {"姓", "名"}
    
    # 2.创建新集合
    s4 = set()
    print(s4)		# set()
    print(type(s4))   # <class "set">
    
    # 这里不能用{}来创建新集合
    s5 = {}
    print(type(s5)) # 输出的结果是<class "dict"> ,因为这时字典的创建方式
    
    

     

    6.6 集合常见操作(增、删、查)

     
    增加数据

    s1 = {10,20}
    # 1. 集合是可变类型
    # add() 用来增加一个单一数据到原集合当中来
    s1.add(100)
    print(s1)      # {100, 10, 20}
    
    # 集合有去重功能,如果追加的数据是集合已有数据,则什么事情都不做
    s1.add(100)
    print(s1)
    
    # update() 用来增加一个数据序列到原集合当中来
    s1.update([10,20,30,40,50])
    print(s1)  # 输出 {100, 40, 10, 50, 20, 30} 有去重功能,如果添加的数据原集合中有的,则不进行操作。
    
    # s1.update(299) 不能直接添加单一数据
    s1.update([299]) # 这种方式的添加就可以
    print(s1)
    

     
    删除数据

    s1 = {10,20,30}
    s2 = {10,20,30}
    s3 = {10,20,30}
    # 1. remove():删除指定数据,如果数据不存在则报错
    s1.remove(10)
    print(s1)  # {20, 30}
    
    # s1.remove(333)
    # print(s1)  # 报错,以为删除的没有这个数据
    
    ============================================================================
    
    # 2. discard():删除指定数据,如果数据不存在不报错
    s2.discard(10)
    print(s2)  # 输出 {20, 30}
    
    s2.discard(666)  # 就算删除的数据不存在也不会报错
    
    ============================================================================
    
    # 3. pop():随机删除某个数据,并返回这个数据
    del_num = s3.pop()  
    print(del_num) 		 # 10
    print(s1)		# {20, 30}
    

     
    查找数据

    
    s1 = {10,20,30,40}
    
    # 用in和not in 判断数据10是否在集合中存在
    
    print(10 in s1)  # Ture
    print(10 not in s1)  # False
    
    

     

    6.7 集合小总结

     

    """
    创建结合
        有数据集合
            s1 = {数据1,数据2,...}
        无数据集合
            s1 = set()
            
    常见操作
        增加数据
            add()
            update()
        删除数据
            remove()
            discard()
    """
    

    最后,欢迎关注公众号【C you again】,获取更多IT技术文章、Java开发面试题、计算机类毕业设计等等。。。。

    在这里插入图片描述
    原文链接:https://blog.csdn.net/weixin_46818279/article/details/108576298


    以上信息来源于网络,如有侵权,请联系站长删除。

    TAG:基础 详细 python

  • 上一篇:详解线程池的作用及Java中如何使用线程池
  • 与“【详细】Python基础(一)”相关的资讯
  • STM32 HAL库之串口详细篇
  • .NET 云原生架构师训练营(模块二 基础巩固 RabbitMQ Masstransit 详解)--学习笔记
  • 醒醒!Python已经支持中文变量名啦!
  • 100行python代码实现五子棋
  • HaaS UI小程序解决方案基础教学 之 快速开始