python 基础题目收藏 基础知识概述

---恢复内容开始---

用户输入:

# score = int(input("请输入分数:"))
# if score >= 90:
#     print("A")
# elif score >= 80:
#     print("B")
# elif score >= 70:
#     print("C")
# elif score >= 60:
#     print("D")
# elif score < 60:
#     print("E")

while循环:

# count = 1
# sum = 0
# while count < 100:
#     if count % 2 == 0:
#         sum -= count
#     else:
#         sum += count
#     count = count + 1
# print(sum)

for循坏:

# lst = []
# li = ["苍老师","东京热","武藤兰","波多野结衣"]
# content = input("请输入你的评论:")
# for el in li:
#     if el in content:
#         content = content.replace(el,"*" * len(el))
# lst.append(content)
# print(lst)

字符串(str):

4. str类型 字符串
        由',",''', """阔起来的内容就是字符串
        字符串是不可变的数据类型.不论你执行任何操作. 源字符串是不会改变的, 每次操作都会返回新字符串

        1. 索引和切片
           索引从0开始, 使用[下标]可以获取到每一个字符, 还可以倒着数
           切片: [起始位置:结束位置:步长]
                1. 顾头不顾尾
                2. 默认从左到右取值.
                3. 当步长为负可以从右往左取值
        2. 字符串相关操作
            1. upper() 转换成大写
            2. stript() 去掉空白
            3. replace(old, new) 把xxx替换成xxxx
            4. split() 切割. 返回列表. 用多长的刀. 就要损失掉多少
            5. startswith() 判断是否以xxx开头
            6. find(), count(), index()
            7. len()  字符串长度. python的内置函数
        3. for循环
            for 变量 in 可迭代对象:
                循环体, 也存在break和continue
            else:
                当循环结束的时候会执行

列表(list):

    1. 什么是列表
        列表是一个可变的数据类型
        列表由[]来表示, 每一项元素使用逗号隔开. 列表什么都能装. 能装对象的对象.
        列表可以装大量的数据
    2. 列表的索引和切片
        列表和字符串一样. 也有索引和切片. 只不过切出来的内容是列表
        索引的下标从0开始
        [起始位置:结束位置:步长]

    3. 列表的增删改查*
        1. 增加
            append() 追加
            insert(index, 元素) 在index位置添加元素
            extend() 迭代添加
        2. 删除
            pop(index) 按照位置删除元素
            remove(元素) 直接删除元素
            del 切片.
            clear() 清空列表
        3. 修改
            索引修改
            切片修改
        4. 查询
            for el in list:
                el
        5. 常用操作
            1. sort() 排序 reverse=True降序
            2. reverse() 翻转
            3. len() 求长度
    4. 列表的嵌套
        降维. 一层一层看

    5. 元组
        只读列表. 只能看啥也不能干.
        使用()表示元组
        如果元祖中只有一个元素(元素, )
        空元组: tuple()
        元祖是一个可迭代对象, 可以使用for循环

    6. range
        range(n) 从0到n-1
        range(m,n) 从m到n-1
        range(m,n,q) 从m到n-1 每q个取1个
        综上就是切片

    7. 使用range和for循环来获取列表中的索引
        for i in range(len(列表)):
            i 索引
            列表[i] 元素

字典(dict):

 字典

        dict  用{}来表示    键值对数据  {key:value}  唯一性

        键  都必须是可哈希的   不可变的数据类型就可以当做字典中的键

        值  没有任何限制


     2. 增删改查

        dic[key] = value

        dic.setdefault(key,value)   如果键在字典中存在不进行任何操作,否则就添加

                                    可以通过key查询,没有这个key返回None

        ====================================================================

        pop(key)                    有返回值  返回的是被删除value
        del dic[key]
        popitem()                   随机删除
        clear()                     清空字典


        ======================================================================

        dic[key] = value
        dic.update(字典)

        =======================================================================

        get(key)
        dic[key]
        for 循环
        setdefault(key)

        =======================================================================

    3.字典的其他操作:

        keys     获取到所有的键存在一个高仿的列表中

        values   获取到所有的值存在一个高仿的列表中

        items    获取到所有的键值对已元祖的形式存在一个高仿的列表中

        解构:

            a,b  = 1, 2

            a,b  = (1,2)

            a,b  = [1,2]

     4. 字典的嵌套:

            dic = {
                'name':'汪峰',
                'age':43,
                'wife':{
                    'name':'国际章',
                    'age':39,
                    'salary':100000
                },
                'baby':[
                    {'name':'熊大','age':18},
                    {'name':'熊二','age':15},
                ]

            }

            dic['baby'][0]['age'] = 19

            print(dic)

is和==区别  编码问题

 1. is 和 == 的区别

        #小数据池

            # 数字小数据池的范围  -5 ~ 256
            # 字符串中如果有特殊字符他们的内存地址就不一样
            # 字符串中单个*20以内他们的内存地址一样,单个*21以上内存地址不一致

            # 黑框框 == 终端

            # a = 'alex@'
            # a1 = 'alex@'
            # print(a is a1)    # Fales

            # n = 5//2
            # n1 = 2
            # print(n is n1)    #True

            # a = 'a'*21
            # b = 'a'*21
            # print(a is b)

            # a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
            # b = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
            # print(a is b)




            # n = -6
            # n1 = -6
            # print(n is n1)  #False

            # n = -5
            # n1 = -5
            # print(n is n1)    #True


            # n = 257
            # n1 = 257
            # print(n is n1)     #True


            #总结:

                # == 比较   比较的俩边的值

                # is   比较   比较的是内存地址   id()

    2. 编码和解码

         ascii 码:

               不支持  中文

               支持    英文  数字  符号

               8位      一个字节

         gbk码  国标:

               支持  中文,英文,数字,符号

               英文  16位   二个字节

               中文  16位   二个字节


         unicode  万国码

                支持  中文,英文,数字,符号

                英文  32 位  四个字节

                中文  32位   四个字节


         utf-8   长度可变的万国码 最少用8位

                英文   8位    一个字节
                中文   24位   三个字节


         Python3中 程序运行阶段 使用的是unicode   显示所有的内容

         bytes类型

            传输和存储都是使用bytes

         pycharm 存储的时候默认是使用utf-8

总结:

    is 和 == 区别

        is  比较内存地址

                id()   ---- 获取内存地址

                小数据池:

                    数字的小数据池范围是 -5 ~ 256

                    字符串:

                        字符串中不能包含特殊符号   + - * / @ 等等
                        字符串单个字符*20以内内存地址都是一样的,单个字符*21以上内存地址不一致

        注意: pycharm是个坑, 一个py文件中所有相同的字符串 一般都是使用一样的内存地址

        ==  比较俩边的值

    编码和解码

        encode(编码方式)     ---- 拿到明文编码后对应的字节

        decode(编码方式)     -----将编码后的字节解码成对应的明文



    注意: 用什么进行编码就要什么进行解码  不然后会懵逼!

集合(set):

set集合
        特点:
            无序, 不重复, 元素必须可哈希(不可变)
        作用:
            去重复
        本身是可变的数据类型. 有增删改查操作.
        frozenset()冻结的集合. 不可变的. 可哈希的
    三. 深浅拷贝(难点)
        1. 赋值. 没有创建新对象. 公用同一个对象
        2. 浅拷贝. 拷贝第一层内容. [:]或copy()
        3. 深拷贝. 拷贝所有内容. 包括内部的所有.

文件操作:

 1. r
        2. w
        3. a
        4. r+
            读写模式.
            需要移动光标进行反复读写
        5. w+
        6. a+
        7. b bytes 读写操作的是字节. 用在非文本上
        8. seek() 移动光标到xx位置
            开头: seek(0), 末尾: seek(0,2)
        9. 文件修改
            创建新文件. 把修改后的内容写入新文件. 删除老文件. 重命名新文件
            import os
            os.remove("")删除文件
            os.rename("源文件", "新文件名") 重命名文件

        for line in f:
            line 一行数据

        with open("文件名") as f:
            不需要关闭文件句柄

---恢复内容结束---

原文地址:https://www.cnblogs.com/SUIFAN/p/9438989.html