第一阶段总结

计算机基础知识与Python简介

一,计算机基础知识

  1. cpu: 相当于人类的大脑,运算和处理问题
  2. 内存: 临时存储数据,断电就消失了
  3. 硬盘: 永久存储数据
  4. 操作系统: 管理计算机硬件与软件资源的计算机程序,控制每个硬件之间数据交互

二,Python简介

  1. 龟叔

  2. 优美、清晰、简单

  3. 主要应用领域:

    • 云计算
    • WEB开发
    • 科学技术、人工智能
    • 系统运维
    • 爬虫
    • 金融量化分析
    • 图形GUI
    • 游戏
  4. Python发展史

    • 1989年,Guido开始写Python
    • 1991年,第一个Python解释器诞生
    • 2004年,最流行的WEB框架Django诞生
    • 2008年,python2和python3版本共存
      • python2:C,Java,C#,源码不统一,功能重复,维护难度大
      • python3:源码统一,维护难度降低了
  5. python是一个编程语言

    • 分类:编译型、解释型,强类型、弱类型

      • 编译型:只翻译一次

        代表语言:C,C++

        优点:运行速度快

        缺点:开发速度慢

      • 解释型:一句一句的翻译,逐行翻译

        优点:开发速度快

        缺点:运行速度慢

        代表语言:Python,JavaS,PHP

    • Python的优缺点

      • 优点:

        1. Python的定位是优雅、明确、简单,初学者容易入门,而且可以编写非常复杂的程序。
        2. 开发效率非常高,Python有非常强大的第三方库
        3. 高级语言,无需考虑如何管理你的程序使用的内存一类的底层细节
        4. 可移植性,由于它的开源本质,Python无需修改就几乎可以在市场上所有的系统平台上运行。
        5. 可扩展性,可以把你的部分程序用C或C++编写,然后在你的Python程序中使用它们。
        6. 可嵌入性,可以把Python嵌入你的C、C++程序,从而向你的程序提供某些功能。
        • 缺点:
          1. 运行速度慢
          2. 代码不能加密
          3. 线程不能利用多CPU
    • Python的种类

      • Cpython: 官方版本,使用C语言实现
      • Jython: 会把Python代码动态编译成Java字节码,然后在JVM上运行
      • IronPython:用C#实现
      • PyPy:Python实现的Python,统一编译后再运行

Python基础

一,Python初始

  1. 写一个Python程序

    print() 打印:打印到屏幕

  2. 变量 运算过程中产生的中间值,存储起来便于下一步运算使用

    • a = 1
      1. 起了一个变量名 a
      2. 有个值 1
      3. 将值赋给变量名 =
    • 命名规范
      1. 只能包含字母、数字、下划线
      2. 不能以数字开头,更不能是纯数字
      3. 不能使用Python中的关键字
      4. 不能使用中文和拼音
      5. 区分大小写
      6. 变量名要具有意义,易分辨
      7. 推荐写法
        • 驼峰体:首字母大写
        • 下划线(官方推荐):alex_age = 98
  3. 常量
    Python中没有真正的常量,约定变量名全部是大写的变量叫常量。

  4. 注释

    给一些不太能够理解的内容写一个描述 -- 增加程序的可读性

    • 单行注释 : # 注释内容,只能注释一行,不能换行
    • 多行注释 :"""注释内容'""' '''注释内容'''
    • 注释后的代码是不执行的
  5. 基础数据类型初始

    1. 字符串str
    2. 整型int
    3. 布尔值bool True(真) => 1,False(假) => 0
    4. 浮点数float
    5. 列表list
    6. 元组
    7. 字典
    8. 集合
  6. 用户输入input

    temp = input(提示语句) 显示提示语句(可以是数字)并要求用户输入一个值

    • python3版本中input获取到的全部都是字符串
    • 拓展:import getpass 密码输入不可见

    ​ psd = getpass.getpass("请输入密码:")

  7. 格式化输出

    1. %s 字符串占位

      name = input("Name:")
      age = input("Age:")
      job = input("Job:")
      hobby = input("Hobbie:")
      info = '''
      ------------ info of %s ----------- #这⾥的每个%s就是⼀个占位符,本⾏的代表 后⾯拓号⾥的 name
      Name : %s #代表 name
      Age : %s #代表 age 
      job : %s #代表 job
      Hobbie: %s #代表 hobbie
      ------------- end -----------------
      ''' % (name,name,age,job,hobbie) # 这⾏的 % 号就是 把前⾯的字符串 与拓号 后⾯的 变量 关联起来
      print(info)
      
      • 字符串格式化的时候,占的数量和填充的数量要一致
      • %% -- 转义,把占位转换成普通的%,当字符串中存在%占位时,必须用%%对%进行转义,才能得到普通的%
    2. %d / %i 整型占位

      占整型的位置,对应的填充必须是整型

    3. f"{}"

      print(f"""
      -------------info------------
      name: {name}  # {}内一般放变量,要放字符串需要加上''
      age: {age}
      sex: {sex}
      job: {job}
      hobby: {hobby}
      --------------end------------
      """)
      # f字符串拼接 -- 3.6版本以上才能使用
      
    4. format

           name = "alex{}wusir{}"
           print(name.format("结婚了","要结婚了")) # 按照位置顺序填充
           
           name = "alex{1}wusir{0}"        # 按照索引位置填充
           print(name.format("结婚了","要结婚了"))
           
           name = "alex{a}wusir{b}"
           print(name.format(a="结婚了",b="要结婚了"))  # 指名道姓填充
      
  8. 基础运算符

    1. 赋值运算符

      a = 1
      a += 1   # a = a + 1
      a -= 1   # a = a - 1
      a *= 1   # a = a * 1
      a /= 1   # a = a / 1
      a //= 1  # a = a// 1
      a **= 1  # a = a ** 1
      a %= 1   # a = a % 1
      
    2. 算术运算符

      • 加 +
      • 减 -
      • 乘 *
      • 除 /
      • 整除(地板除) //
      • 幂运算 **
      • 取余 %
    3. 逻辑运算符

      • not 非,非真即假,非假即真

      • and 与,并且,两边都为真的时候才是真

        print(1 and 9)     # and 两边都是真的时候取and后面的内容
        print(False and 0) # 两边都是假的时候取and前面的内容
        
      • or 或,或者,有一边为真就是真

        print(1 or 2)   # or 两边都为真的时候取or前面的内容
        print(1>2 or 2) # 有一边为真的时候返回真的内容
        print(0 or 2>3) # 两边都为假的时候取or后面的内容
        
      • 运算顺序

        () > not > and > or

    4. 比较运算符

      == != > >= < <=

    5. 成员运算符

    • in 可以判断xxx字符串是否出现在xxxxx字符串中

    • not in

      a = "abc"
      print("a" in a)   # True
      print("A" in a)   # False
      print("a" not in a)  # False
      
    1. 身份运算符
    • is 判断是不是同一个值,指向同一个虚拟内存
    • is not
  9. 编码

    • ASCII(American Standard Code for Information Interchange,美国标准信息交换代码)是基于拉丁字⺟的⼀套电脑编码系统,主要⽤于显示现代英语和其他⻄欧语⾔,其最多只能⽤ 8 位bit来表示(⼀个字节Byte),即:2**8=256,所以,ASCII码最多只能表示 256 个符号。

    • GBK, 国标码占⽤2个字节. 对应ASCII码GBK直接兼容. 因为计算机底层是⽤英⽂写的. 你不⽀持英⽂肯定不⾏. ⽽英⽂已经使⽤了ASCII码. 所以GBK要兼容ASCII.

    • Unicode,万国码,英文占2个字节,中文占4个字节

    • UTF-8: 每个字符最少占8位. 每个字符占⽤的字节数不定.根据⽂字内容进⾏具体编码. 是⽬前使⽤频率最⾼的⼀种编码。英文占1个字节,欧洲文字占2个字节,亚洲文字占3个字节。

    • 单位转换

      8bit = 1Byte
      1024Byte = 1KB
      1024KB = 1MB
      1024MB = 1GB
      1024GB = 1TB

  10. 编码进阶

    • python3内存使用的是unicode
    • python2内存使用的是ascii
    • 用什么编码就用什么解码
    • encode():编码
    • decode():解码

二,流程控制与循环

  • 占位符

    pass 和 ...

  • 计算字符串的⻓度

    len(字符串) -- 工厂函数 -- 所有类型都能用,除了int和bool 求元素个数

  1. 流程控制语句 if

    • if 条件A : # 条件判断,> < == 等

      ​ 代码块A # 条件A成立时运行代码块A

      elif 条件B:

      ​ 代码块B # 条件A成立,条件B成立时运行代码块B

      else:

      ​ 代码块C # 以上条件均不成立时运行代码块C

    • 嵌套if

      if 条件A :

      ​ if 条件B:

      ​ 代码块 # 条件A成立,并且条件B成立时运行代码块

  2. while循环

    • while 条件A:
      代码块A(循环体) # 当条件A成立时,运行循环体
      else:
      代码块B # 当条件A不成立时,运行代码块B

      index = 1
      while index < 11:
      	if index == 8:
      '''break,终止本层循环,不运行后面的代码,如果循环是通过break退出的. 那么while后⾯的else将不会被执⾏, 只有在while条件判断是假的时候才会执⾏这个'''
      '''continue,跳出本次循环,进行下次循环,重新判断条件,不运行后面的代码'''
      	else:
      		print(index)
      	index = index+1
      else:
      	print("你好")
      
  3. for循环

    # for 变量 in  可迭代对象:
    #	pass
    s = "1234567890"
    for each in s:          # 遍历字符串
        print(each)         # 1 2 3 4 5 6 7 8 9 0
    print(each)             # 0   注意
    
  4. range

    • 语法range(start,end,step): 范围,从start到end,不包含end,步长step默认是1

    • python3中打印range()会打印本身,python2中会打印出列表

      for each in range(1,10):
      	print(each)
      # 1  2  3  4  5  6  7  8  9
      

三,基础数据类型

  1. 字符串str 用' ',"" "" ,''' ''',""" """,引起来的内容是字符串

    字符串拼接:"a" + "b" => "ab" ,都是字符串才能相加

    字符串 * 数字: "a" * 3 => "aaa"

    1. 用于储存小量的数据

    2. python中用' '," ",''' ''',""" """括起来的就是字符串

    3. 常用操作

      1. 索引: 索引就是下标,从左向右, 从0开始;从右向左,从-1开始

        num = "1234567890"
        print(num[1])  => 2
        print(num[4])  => 5
        print(num[-1]) => 0
        print(num[-2]) => 9
        print(num[21]) # 索引超出范围,报错
        
      2. 切片:使⽤索引来截取部分字符串的内容

        • 语法: str[start: end: step]

        • 规则: 顾头不顾尾, 从start开始截取, 截取到end位置,但不包括end。

          num = "0123456789"
          num[::] == num[:]  # 从头取到尾
          print(num[0:3])  =>  012 # 不包含索引3对应的"3"
          print(num[5:8])   =>  567
          print(num[5:])    =>  56789  # 想取到最后,end可以不写
          print(num[5:20])  =>  56789  # 索引超出范围,不会报错
          print(num[-1:-5:-1]) => 9876 # step步长决定取值的方向,默认为1
          print(num[1:7:2]) =>  135    # step步长决定取值的步子大小,即每step个取一个
          
      3. 常用方法

        • 切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的
        name = "Hello World"
        print(name.upper()) => HELLO WORLD  字母全部转换成大写
        print(name.lower()) => hello world  字母全部转换成小写
        print(name.startswith("H"))  => True  是否以"H"开头
        print(name.endswith("d"))    => True  是否以"d"结尾
        print(name.count("o"))       => 2     统计"o"出现的次数
        print(name.replace("H","A",次数)  => Aello World  # 将H替换成A,默认全部替换,可以输入替换次数
        
        a = "  Alex  "
        print(a.strip()) => Alex  # 去掉两端的某些元素,()内可以指定元素,默认是空白(空格和\n)
        
        b = "1,2,3"
        print(b.split(",")) => ["1","2","3"]  # 分割,可以指定用于分割的元素,分割后损失这个元素,默认以空格分隔,返回一个列表。
        
        • is 判断系列
        name.isdigit()   # 判断是不是阿拉伯数字,有漏洞
        name.isdecimal() # 判断是不是十进制,可以用于判断数字
        name.isalpha()   # 判断是不是中文和字母
        name.isalnum()   # 判断是不是中文,字母和数字
        
  2. 整型int

    1. 用于计算和比较,在python3中所有的整数都是int类型

    2. 二进制和十进制的转换

      • 十进制转换成二进制:

        正整数转换成二进制:除二取余,倒序排列,高位补零

        14 % 2 = 0
        7  % 2 = 1
        3  % 2 = 1
        1  % 2 = 1
        0
        14转换为二进制为:0000 1110
        

        负整数先转换成对应的正整数,转换成二进制,对二进制取反,再对结果加一

      • 二进制转换成十进制:

        先将二进制补齐位数,如果首位是0代表是正整数,首位是1代表是负整数

        • 正整数:补齐位数后,将二进制中的位数分别将下边对应的值相乘,然后相加得到十进制

          1010  
          # 先补齐位数  =>  0000 1010     128  64   32  16   8   4   2   1 常用的8位
          2**3 *1 + 2**2 * 0 + 2**1 * 1 + 2**0 * 0  =  10
          
        • 负整数,先对二进制取反,再进行换算

    3. bit_length()

      求十进制数转换成二进制时所占用的长度

  3. 布尔值bool True(真) => 1,False(假) => 0

    • True 真 非0数字 非空字符串

    • False 假 0 空字符串

    • 类型转换:想要转换成什么类型,就用这个类型把需要转换的内容括起来

      a = "hahahahaha"
      b = "123456"
      c = 123456
      a1 = bool(a)  => True
      b1 = int(b)   => 123456
      c1 = str(c)   => "123456"
      
  4. 列表list

    1. 可以有序的存储大量数据,用以[ ]括起来,每个元素⽤' , '隔开⽽且可以存放各种数据类型。

    2. 列表时可变的,即可以在本身上进行修改。

    3. 列表的索引和切片

      • 列表和字符串一样是有索引的,也是可迭代的

        li = [1,2,3,"123",True]
        print(li)
        print(li[-2],type(li[-2]))  # 索引查找
        print(li[1:4])              # 支持切片   切片所得是列表
        print(li[-2:1:-1])          # 支持步长
        
    4. 列表的增删改查

      • 注意, list和str是不⼀样的. lst可以发⽣改变. 所以直接就在原来的对象上进⾏了操作

      • li.append("4")     # 追加,在末尾添加一个元素
        li.extend([5,6])   # 扩展,迭代添加."10" => "1","2"
        li.insert(0,"A")   # 按索引位置插入一个元素,效率特别低
        
        li2 = [4,5,6]
        li3 = li + li2     # 列表合并
        
      • lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]
        deleted = lst.pop() # 弹出,可以指定索引位置,默认弹出最后一个元素,有返回值,返回的是弹出的元素
        el = lst.pop(2) # 删除2号元素
        lst.remove("麻花藤") # 删除指定元素,必须知道元素的内容
        lst.remove("哈哈") # 删除不存在的元素会报错
        lst.clear() # 清空list,清除列表内全部的信息,得到一个空列表
        del lst[2]   # 删除特定索引位置的元素
        del lst[1:3] # 删除特定索引范围内的元素,也可以改变步长
        
      • li = [1,2,3,"123",True]
        li[0] = "1"         # 指定位置修改
        li[1:3] = [9,8,7]   # 迭代修改,支持切片修改
                            # 使用步长时注意取几个必须放几个,步长为1时则不需要注意个数。
        
      • li = [1,2,3,"123",True]
        print(li[1])   # 指定索引位置查询
        
        for each in li:
        	print(each)
        # 列表是⼀个可迭代对象, 所以可以进⾏for循环
        
        
    5. 列表的嵌套

      采用降维操作,一层一层的看

      li = [1,2,3,"123",[9,8,7]]
      li[-1][0] => 9
      
  5. 元组tuple

    1. 俗称不可变的列表。⼜被成为只读列表,元组也是python的基本数据类型之⼀,⽤⼩括号括起来,⾥⾯可以放任何数据类型的数据,查询可以,循环也可以,切片也可以,但就是不能改。

      tu = (1,2,3,"123",[1,2,3])
      for each in tu:
      	print(each)  # 元组也是可以迭代的,可以用for循环遍历
      
      tu = (1,)   # 注意,如果元组中只有一个元素,一定要在后面添加一个逗号,否则就不是元组
      tu = () 
      tu = tuple() # 创建空元组
      
      • 关于不可变, 注意: 这⾥元组的不可变的意思是⼦元素不可变。⽽⼦元素内部的⼦元素是可以变,这取决于⼦元素是否是可变对象。
      • 元组也有count(), index(), len()等⽅法
    2. 元组的嵌套

      • 参照列表的嵌套
  6. 字典dict

    1. 字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯⼀的. 在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中.这种算法被称为hash算法, 所以, 在dict中存储的key-value中的key必须是可hash的,可哈希就意味着不可变.

    2. 语法

      {key1: value1, key2: value2....}

      注意:key必须是不可变的(可哈希的),value可以保存任意类型的数据

    3. 特点

      • 无序:python3.6版本以上默认了咱们定义的顺序,python3.5以下是随机显示的.
      • 可变的
      • 可以存储大量数据,比列表还要大
      • 能够将数据进行关联,比较消耗内存
    4. 字典的相关操作

      1. 新增

        dic = {"a":"b","b":"c"}
        dic["c"] = ["d"]   # 给出key和value添加,如果key已存在则会替换value
        dic.setdefault("c","d") # 先去字典中查看key存不存在,如果key存在会返回key所对应的value(可用于查找),如果key不存在就添加key和value
        
      2. 删除

        注意:字典没有remove

        dic = {"a":"b","b":"c"}
        dic.pop("a")  # 指定key弹出,有返回值,返回删除的value
        dic.popitem() # 随机弹出,有返回值,返回删除的value
        del dic["a"]  # 指定key删除
        del dic       # 删除整个字典
        dic.clear()   # 清空字典,得到空字典
        
      3. 修改

        dic[key] = "新的值"         # 指定key修改,key不存在就新增
        dic.update({1:2,'a':'a1'})  # 用字典更新字典,存在的替换,没有的新增,原来有这次没有的不变
        
      4. 查询

        查询只能通过key获取value,不能通过value获取key.

        print(dic[key])       # 指定key查找value,key不存在会报错
        print(dic.get(key,"返回"))  # 指定key查找value,key不存在会返回给出的返回值,默认None
        
      5. 其他相关操作

        dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科⽐"}
        dic.keys()   # 得到key的高仿列表,但不是列表,不支持索引,支持迭代遍历
        dic.values() # 得到value的高仿列表
        dic.items()  # 得到由(key,value)成对组成的元组组成的列表
        for el in dic: # 遍历列表得到key
        for el in dic.keys():
        for el in dic.values():
        for el in dic.items():   =>  (key,value)
        for k,v in dic.items():  => 得到key和value
        for el in enumerate(dic,start): # 给你要迭代的对象加一个序号start默认是0,枚举
        
      6. 字典的嵌套

        dic = {
            101:{1:['周杰伦','林俊杰'],2:{'汪峰':['国际章','前妻一','前妻二']}}
            102:{1:['李小龙','吴京','李连杰'],2:{'谢霆锋':['张柏芝','王菲']},3:['大象','奇奇']}
            103:{1:['郭美美','干爹'],2:{'王宝强':['马蓉','宋哲']}}
        }
        print(dic["102"][3][0]) => "大象"
        # 逐层用key查找
        
  7. set集合

    1. 集合就是一个没有value的字典:无序,去重,可哈希

    2. 集合是可变的

    3. 语法

    4. 相关操作

      • s.update()  # 迭代添加
        s.add()     # 单个添加
        
      • s.pop()     # 随即删除
        s.remove()  # 指定元素删除
        s.clear()   # 清空
        del s       # 删除整个集合
        
      • 只能删了再加

      • 可以用for循环遍历

      • 其他操作

        s1 = {1,2,3,4}
        s2 = {3,4,5,6}
        print(s1 - s2)  # 差集 1,2
        print(s1 | s2)  # 并集 1,2,3,4,5,6
        print(s1 & s2)  # 交集 3,4
        print(s1 ^ s2)  # 反交集 1,2,5,6
        print(s1 > s2)  # s1是s2的超集,父集
        print(s1 < s2)  # s1是s2的子集
        f_s = frozenset({1,2,3,4,5,6}) # 冻结集合--变成不可变
        
      • 重要用法

        lis = [1,2,2,3,2,4,5,6,5,6,7]
        print(list(set(lis)))
        => [1,2,3,4,5,6,7]  # 去重是集合最重要的用法
        
  8. 基础数据类型补充

    1. 字符串str

      s = "aa111aa"
      print(s.capitalize())  # 首字母大写,只有第一个字母大写
      print(s.title())       # 每个单词首字母大写,单词中间用特殊字符或中文隔开
      print(s.count("a"))    # 统计"a"出现的次数
      print(s.swapcase())    # 大小写转换
      print(s.find("a"))     # 查找"a"的第一个索引,查找不到的时候返回-1
      print(s.index("a"))    # 查找"a"的第一个索引,查找不到的时候报错
      
    2. 列表list

      li = [1,2,3,4]
      l2 = list("1234")   # 定义的一种方式
      print(li.count(1))  # 统计1出现的次数
      print(li.index(1))  # 查找1的第一个索引,查找不到就报错
      li.reverse()         # 原地反转
      li.sort(reverse=True) # 排序,默认升序,加True就降序
      
    3. 元组tuple

      tu = (1,2,3,4,5)
      tu1 = tuple("12345") # 定义的一种方式
      tu.count(1)  # 统计
      tu.index(1)  # 通过元素找索引,找不到就报错
      
    4. 字典dict

      dic = {1:"a",2:"b"}
      dic1 = dict(k=1,k1=2)  # 定义的一种方式
      dic.popitem()   # 随机删除,返回删除的值,3.6版本后默认删除最后一个键值对
      dic2 = dict.fromkeys("123",1)  # 批量创建字典,迭代key,value相同,指向同一内存地址
      
      
    5. 结合set

      s = set("1234")  # 定义的一种方式
      
    6. 类型转换

      str => int :字符串中必须全部都是十进制的数字
      int => str :直接转换
      str => list :
      s = "1234"
      lst = list(s) => ["1","2","3","4"]
      或用split()切割
      list => str :使用join进行拼接,元素中不能有int
      list => tuple :直接转换
      set => list :直接转换
      总结:
      字符串 -- 数字  :字符串中必须都是十进制的数字
      数字 -- 字符串  :直接转换
      列表 -- 字符串  :join()拼接--可迭代的对象中不能出现数字
      字符串 -- 列表  :split()分割
      除字典外,容器数据类型都能直接相互转换
      
    7. 总结

      有序: str,int,bool,list,tuple
      无序: dict,set
      可变: list,dict,set
      不可变: str,int,bool,tuple
      
      访问方式:
      直接访问: int,bool,set
      顺序访问:str,list,tuple
      键访问: dict
      
    8. 坑人的删除

      li = [1,2,3,4,5]
      # 面试题:要求用一个for循环对删除上述列表索引为奇数位置的元素
      for el in range(len(li)-1,-1,-1):
          if el % 2 == 1:
              li.pop(el)
      print(li)
      # 尽量不要在for循环遍历列表的同时修改列表本身的大小
      
      # for循环迭代字典过程中改变字典的大小会报错
      

四,小数据池和深浅拷贝

  1. 小数据池

    1. 小数据池:⼀种数据缓存机制. 也被称为驻留机制. 各⼤编程语⾔中都有类似的东⻄.用于提高效率.
    2. 支持的数据类型:str,int,bool
    3. id() -- 查看元素的内存地址
    4. is 和 ==
      • is 判断两个元素的内存地址是否相同
      • == 判断两个元素的值是否相同
    5. 小数据池规则:
      • 数字:-5~256
      • 字符串:
        1. 字符串在做乘法(乘数不为1)的时候总长度不能超过20
        2. 自己定义的字符串长度不限制,字符串必须是由字母,数字,下划线组成
        3. 特殊字符(中文除外)定义1个的时候,进行驻留
    6. 代码块:一个文件,一个模块,一个函数,一个类,终端中每一行都是一个代码块
      • 数字:全部驻留
      • 字符串:
        1. 自己定义的字符串全部驻留
        2. 字符串做乘法(乘数不为1)的时候总长度不能超过20
        3. python3.7以上版本乘法的时候总长度不能超过4096
  2. 深浅拷贝

    1. 赋值 =

      赋值没有创建新的空间,多个变量指向同一个内存地址.

    2. 浅拷贝

      • l2 = l1[:] 和 l2 = l1.copy()
      • 只拷贝第一层元素
      • 会创建一个新的容器,容器中的元素和原容器的元素指向同一个内存地址
    3. 深拷贝

      • import copy

        l2 = copy.deepcopy(l1)

      • 不可变的数据类型和原数据指向同一空间

      • 可变数据类型会创建一个新的空间

五,文件操作

  1. 语法

    # f = open("文件路径", mode="模式", encoding="编码")
    # open()   调用操作系统打开文件
    # mode     对文件的操作方式
    # encoding 文件的编码  --  存储编码要统一
    #           win -- 默认gbk
    #           linux,mac -- 默认utf-8
    # f        文件句柄 -- 操作文件的途径
    
    # 另一种打开文件的方式: 帮助自动关闭文件;可以同时开多个文件,用逗号隔开;也可以同时操作一个文件
    with open("a", mode="r", encoding="utf-8") as f,\
         open("b", mode="w", encoding="utf-8") as f1: 
    
    import os
    print(os.getcwd()) # 查看当前工作路径
    os.remove() # 删除文件
    os.rename() # 更改文件名.(旧名,新名)
    
  2. 模式

    • # r
      f = open("a", mode="r", encoding="utf-8")
      contend = f.read()   # 全部读取
      print(contend)
      print(f.read(3))     # 字符读取
      print(f.readline())  # 读取一行,()内可以加入需要读取本行的几个字符
      print(f,randlines()) # 读取每一行,存储到列表中
      for line in f:       # 一行一行读取  -- 防止内存溢出
           print(line)
      
      # rb -- 读非文本文件,不能指定编码,
      f = open("a", mode="rb")
      print(f.read(3))     # 读取3个字节
      
      # r+ -- 读写 -- 先读后写
      f = open("a", mode="r+", encoding="utf-8")
      print(f.read())
      f.write("你好啊")
      f.flush()
      f.close()            # 关闭文件,释放内存
      
      # r+b
      
    • # w 清空写 -- 没有文件就创建,有就打开,先清空,再写入
      f = open("a", mode="w", encoding="utf-8")
      f.write("乳娃娃")  # 不能写入int
      f.flush()
      f.close()
      
      # wb
      # w+ -- 先清空,写入,再读.用不着
      # w+b
      
      # a 追加写 -- 文件末尾写入
      f = open("a", mode="a", encoding="utf-8")
      f.write("啊啊啊啊啊啊啊,好烦啊")
      f.flush()
      f.close()
      
      # ab
      # a+ -- 追加读,光标默认在末尾
      f = open("a", mode="a+", encoding="utf-8")
      print(f.read())
      f.write("真的废物")
      
      # a+b
      
  3. 其他操作

    • 绝对路径 -- 从磁盘的根处查找
    • 相对路径 -- 相对于当前文件进行查找
    • tell() -- 查看光标位置,单位是字节
    • seek(偏移量,起始位置) -- 起始位置默认0--开头,1--当前位置,2--末尾
posted @ 2019-06-14 14:38  怀心抱素  阅读(149)  评论(0编辑  收藏  举报