Python基础

1.Python简介

1.1 Python是什么编程语言

从编程语言的几个方向来说

1. 编译型和解释型
   • 什么是编译型？什么是解释型？
     • 编译型：就是把源代码一下全部都编译成二进制文件（优点：执行效率高。缺点：开发效率较低）
     • 解释型：就是源代码从上到下一条一条交给计算机，计算机收到一条就执行一条（优点：开发效率高。缺点：执行效率较低）
   • Python属于解释型
2. 静态语言和动态语言
   • 什么是静态语言？什么是动态语言？
     • 静态语言：创建变量时需声明变量的数据类型
     • 动态语言：创建变量时不需要声明变量的数据类型
   • Python属于动态语言
3. 强类型定义语言和弱类型定义语言
   • 什么是强类型定义语言？什么是弱类型定义语言？
     • 强类型定义语言：如果一个变量指定了一个数据类型，那么如果不强制转换那它永远就都是这个数据类型了
     • 弱类型定义语言：一个变量可以赋予多个数据类型的值
   • Python属于强类型定义语言

2.Python入门

2.1输出

#python2 写法
print "Hello World!"

#python3 写法
print("Hello World!")
#如果要输出带有换行的，那么就用三对引号
print("""
第一行
第二行
""")
#如果在执行时报错或者乱码（输出中文会）
#在py文件的头加入:

#-*- coding:utf-8 -*-

2.2变量

• 什么是变量？

  • 首先变量有一个名字，然后它有一个值。这就是变量

    • v(变量名) = 1（值）

    • v = 1

  • 补充：这里的v所指向的不是1这个值，而是这个值所存在的内存地址

• 变量的命名规则：

  • 变量名由字母，数字，下划线组成

  • 变量不能是数字开头

  • 禁止使用Python里面的关键字和内置函数的名字

    • 常见关键字（help("keywords")可以查看）

      help("keywords")
      
      False               def                 if                  raise
      None                del                 import              return
      True                elif                in                  try
      and                 else                is                  while
      as                  except              lambda              with
      assert              finally             nonlocal            yield
      break               for                 not
      class               from                or
      continue            global              pass
      

    • 如果记不住还有一点就是在使用IDE的时候如果是Python关键字那么它会变颜色

  • 要见名知意（如下：

    name = "nanke" #这让别人知道名字是nanke
    #而不是
    a = "nanke"

  • 变量名写法

    • 驼峰体：OnePage
    • 下划线法：one_page

2.3常量

• ? 常量就是一般不更改的变量，一般用大写来表示。如：

  LANGUAGE_NAME = "Python"

2.4注释

• 单行注释

  #print("Hello World!")

• 多行注释

  """
  name = "nanke"
  print(name)
  """

2.5基本数据类型

其实本不该在这里列举的，因为基本数据类型里面有好多好多的操作方法。在这里我就简单介绍一下什么是整形，什么是字符串，什么是布尔

• 整形

  val = 123

• 字符串

  val = "123"

• 布尔

  val = True
  val = False

  这里，是引号包裹起来的都是字符串，不管里面是什么

  然后，不是引号包裹起来的数字几乎都是整型了

  布尔型就只有两个一个真一个假（True和False）

2.6输入

• python2

  name = raw_input("请输入你的名字:")

• python3

  name = input("请输入你的名字：")

• 注意：不管是Python2还是Python3里面name接收的值的数据类型都是字符串类型。下面来举个栗子

  n1 = input("请输入一个数字:")
  n2 = input("请输入一个数字:")
  val = n1 + n2
  print(val)

  • 在这里我n1输入1 ，n2输入2。那么val的值会是什么呢？
  • 可能初学者会认为是3，但实际上并不是。
  • 它会输出12（注：这里的12依旧是字符串）
  • 为什么是12呢？因为这是做的字符串加法
  • 如果我想让它变成真正的1+2呢？如下

  n1 = input("请输入一个数字:")
  n2 = input("请输入一个数字:")
  val = int(n1) + int(n2)
  print(val)

2.7if else elif

• if

  • if 就是如果XX 那就XX

  • 说人话就是 如果条件满足 就执行什么

  • 比如

  • if 你是男人：

    ? 进男厕所

  if gender == '男':
      print('进男厕所')

• if else

  • 如果理解了上一个，那么这个也就好理解了
  • 如果是男人就进男厕所，否则进入女厕所

  if gender == '男':
      print('进男厕所')
  else:
      print('进女厕所')

• if elif else

  • 如果理解了前两个，这个就瞬间懂了

  if gender == '男':
      print('进男厕所')
  elif gender == '女':
      print('进女厕所')
  else:
      print('进宠物医院吧')

3.运算符

3.1while循环

• 什么是循环？

  • 循环就好像是在操场跑圈，一直围绕着操场跑。
  • 当然，一个人也不能无止境的跑，那么肯定有停下来的条件。
  • 那么我让它跑十圈就停下来

  i = 1
  while i <= 10:
      print('跑了'+str(i)+'圈')
      i = i + 1
  """
  跑了1圈
  跑了2圈
  跑了3圈
  跑了4圈
  跑了5圈
  跑了6圈
  跑了7圈
  跑了8圈
  跑了9圈
  跑了10圈
  """

• break

  • 如果在跑10圈的过程中，如果外面突然打雷下雨，那么是不是就得停下来了
  • 那么我让它在第五圈的时候就不跑了

  i = 1
  while i <= 10:
      print('跑了'+str(i)+'圈')
      if i == 5:
          break
      i = i + 1
  """
  跑了1圈
  跑了2圈
  跑了3圈
  跑了4圈
  跑了5圈
  """

  • 这里他跑了五圈就停止了。
  • 所以很明显break的作用就是退出这一整个循环

• continue

  • 如果假设我们跑的这十圈里面可以使用接力，一个人替一个人跑一圈
  • 那么我在第五圈的时候使用接力

  i = 1
  while i <= 10:
      if i == 5:
          i = i + 1
          continue
      print('跑了'+str(i)+'圈')
      i = i + 1
  """
  跑了1圈
  跑了2圈
  跑了3圈
  跑了4圈
  跑了6圈
  跑了7圈
  跑了8圈
  跑了9圈
  跑了10圈
  
  """

  • 这里可以看出来continue的作用就是退出这一个循环

• 总结

  • break
    • 就是结束整个循环
    • 如果执行到break，那么就跳出这个循环体
  • continue
    • 就是结束这一次的循环
    • 如果执行到continue，并不会跳出整个循环，只是结束这个循环的这一次的循环

3.2格式化输出

• %s

  name = 'nanke33'
  msg = "今天是个好日子，%s好开心"%(name,)
  print(msg)

  • 结果是
    • 今天是个好日子，nanke33好开心

• %d和%i

  n1 = 1
  n2 = 2
  msg = "%d+%i=%d"%(n1,n2,n1+n2,)
  print(msg)

  • 结果是
    • 1+2=3
  • 这里%d和%i都是数字

• %%

  print("80%%")

  • 结果是
    • 80%
  • 这里要使用百分号%就得多加一个百分号来转义，不然Python会以为一个百分号是一个占位符

3.3运算符

3.3.1 算术运算符

#  +
print(1+2)  #3
#  -
print(2-1)  #1
#  *
print(2*2)  #4
#  /  除 (python3)
print(10/4) #2.5
#  /  除 (python2)
print(10/4) #2
#  %  取模
print(9/2)  #1
#  **  n1**n2 n1的n2次方
print(3**2)  #9
#  //  取整数
print(10/4)  #2

3.3.2比较运算符

#由于是比较运算，所以只有是或不是，返回布尔值，真或假
n1 = 1
n2 = 2
#等于
print(n1 == n2)   #False
#不等于
print(n1 != n2)   #True
#大于
print(n1 > n2)    #False
#小于
print(n1 < n2)    #True
#大于等于
print(n1 >= n1)   #False
#小于等于
print(n1 <= n1)   #True

3.3.3赋值运算符

n1 = 1
n2 = 2
#  =
n3 = n1 + n2
#  += 
n1 += n2 # n1 = n1 + n2
#  -= 
n1 -= n2 # n1 = n1 - n2
#  *=
n1 *= n2 # n1 = n1 * n2
#  /=
n1 /= n2 # n1 = n1 / n2
#  %=
n1 %= n2 # n1 = n1 % n2
#  **=
n1 **= n2 # n1 = n1 ** n2
#  //=
n1 //= n2 # n1 = n1 // n2

3.3.4逻辑运算

• and（与）

  print(True and False) #False

• or（或）

  print(True or False) #True

• not（非）

  print(not True) #False

3.3.5成员运算

• in

  print('a' in 'abc')#True

• not in

  print('a' not in 'abc')#False

4.数据类型

4.1整形（int）

• 在Python2中有int 和 long

• 在Python3中只有int

• 在Python2中的/要显示小数

  from __future__ import division 
  value = 3/2
  print(value)

4.2布尔型（bool）

• True
• False

4.2.1转换

#整形除了0为False，其余的都是True
val = bool(1)  #True
val = bool(0)  #False

#字符串除了空字符串为False，其余的都是True
val = bool("")  #False
val = bool("nanke")  #True

• 其余的数据类型除了空的是False,非空的都是True

4.3字符串（str）

4.3.1字符串相加

n1 = "1"
n2 = "2"
val = n1 + n2
print(val)
#结果是12

4.3.2字符串相乘

• 如果有学过其他语言的小伙伴打印n条Hello World！会用循环来。在Python中有个简单的方法就是字符串相乘

  val = "Hello World!\n"
  print(val*8)
  #结果
  #Hello World!
  #Hello World!
  #Hello World!
  #Hello World!
  #Hello World!
  #Hello World!
  #Hello World!
  #Hello World!

4.3.3索引

• 字符串的索引其实很简单，就比如一个单词Hello，它的第一个是H第二个是e...类似的，找它第几个就是字符串的索引，使用方法：

  val = "Hello"
  print(val[1])
  #结果e

  • 这里有人问，为啥不是H而是e，不是第一个吗？
  • 因为计算机里面是从0开始数数的，而不是1.
  • 所以这里的val[1]就代表val这个变量的第二个单词啦

4.3.4切片

• 什么是切片？切片其实就是把一个单词切成你想要的。

• 如：Hello你只想要Hel怎么做呢？

  val = "Hello"
  print(val[0:3])
  #结果
  #Hel

  • 这个时候可能又会问，0-3不是四个吗？为啥只有三个
  • 这里我的理解是因为它的区间是半开半闭区间[0,3）

4.3.5步长

• 什么又是步长呢？

• 我们又拿Hello举栗子，如果我想要Hlo这要怎么办呢？

  val = "Hello"
  print(val[::2])
  #结果
  #Hlo

  • 可能机智的你已经意识到了对于字符串变量[a???c] a b 代表范围 c 代表步长

  • 我们再举个栗子123456789

  • 如果我要这里面的1 3 5 7怎么做呢

    val = "123456789"
    print(val[0:7:2])
    #结果
    #1357

4.3.6字符串常用方法

4.3.6.1全部大写

• 见名知意就是把字符串的小写全部转换成大写

  val = "Hello"
  print(val.upper())
  #结果
  #HELLO

4.3.6.2全部小写

val = "Hello"
print(val.lower())
#结果
#hello

4.3.6.3首字母大写

val = "hello"
print(val.capitalize())
#结果
#Hello

4.3.6.4大小写转换

• 这个就是大写换成小写，小写换成大写

val = "Hello"
print(val.swapcase())
#结果
#hELLO

4.3.6.5判断以什么开头

val = "Hello"
print(val.startswith('H')) #True
val = "Hello"
print(val.startswith('h')) #False
val = "Hello"
print(val.startswith('e')) #False

• 所以这个是区分大小写的

4.3.6.6判断以什么结尾

val = "Hello"
print(val.endswith('o')) #True
val = "Hello"
print(val.endswith('O')) #False
val = "Hello"
print(val.endswith('h')) #False

4.3.6.7统计出现的次数

• 拿Hello来说 l出现2次 其余的都只出现过一次

val = "Hello"
print(val.count("l"))#2
print(val.count("H"))#1

4.3.6.8查找下标

• 如Hello H是第0个下标就是0

val = "Hello"
print(val.find("H"))#0

• 那么如果是l呢？

val = "Hello"
print(val.find("l"))#2

• 结果不应该是2 和 3吗?

  • 因为这个函数的运行机制就是找到一个就不找了，所以就是2

• 那如果找一个这个字符串里面不存在的呢

  val = "Hello"
  print(val.find('a')) #-1

  • 所以找不存在的就会返回-1给我们

4.3.6.9字符串替换

• 定义变量name = "nanke33" 我要把nanke33换成nanke2333怎么做呢？

  name = "nanke33"
  print(name.replace("33","2333"))#nanke2333

4.3.6.10去掉头尾两边的空格

val = " Hello World! "
print(val.strip())#Hello World

• 很明显不能去掉中间的额空格

4.3.6.11字符串分割

• 如果有这么一个name.age.gender要分割成name age gender怎么做呢

val = "name.age.gender"
print(val.split("."))#['name', 'age', 'gender']

• 是不是和我们想的输出结果不一样呢？
  • 对的，这个分割之后是以列表的形式返回给我们
  • 什么是列表呢？我们下面会说

4.3.6.12字符串格式化

val = "Hello {}"
new_val = val.format("World!")
print(new_val)#Hello World!

4.3.6.13is

• isdigit()判断是不是阿拉伯数字

  val = "nanke33"
  print(val.isdigit())#False

• isalnum()判断是不是数字和字母

  val = "nanke33"
  print(val.isalnum())#True

• isalpha()判断是不是纯字母和汉字

  val = "nanke33"
  print(val.isalpha())#False

• 下面就是补充一点点了

  • len()获取长度

    val = "nanke33"
    print(len(val))#7

  • while循环打印一个字符串

    val = "nanke33"
    count = 0
    while count < len(val):
        print(val[count])
        count += 1

  • for循环打印一个字符串

    val = "nanke33"
    for item in val:
        print(item)

4.4列表（list）

4.4.1什么是列表

• 在之前我们已经看到过列表了，[‘name‘,‘age‘,‘gender‘]
• 类似这样子的就是列表，当然列表不仅仅能存字符串，它还能存别的数据类型，还可以列表里面嵌套列表

4.4.2列表的索引

• 如果理解了前面字符串索引的意思，那么列表的索引也就明白了

  lst = ['name','age','gender']
  print(lst[0])#name

• 你以为这样就结束了？不不不还有呢，我还能改lst[0]的值

  lst = ['name','age','gender']
  lst[0] = "姓名"
  print(lst)#['姓名', 'age', 'gender']

4.4.3列表的切片

• 其实列表的切片与字符串的切片几乎都差不多

  lst = ['nanke1', 'nanke2', 'nanke3', 'nanke4', 'nanke5', 'nanke6']
  print(lst[0:4])#['nanke1', 'nanke2', 'nanke3', 'nanke4']
  print(lst[1:5:2])#['nanke2', 'nanke4']

4.4.4列表的常用函数

• append()

  lst = [1, 2, 3]
  lst.append(4)
  print(lst)#[1, 2, 3, 4]

• insert()

  lst = [1, 2, 3]
  lst.insert(1, 4)#第一个参数是在下标是1的地方插入第二个参数，原来的往后移动
  print(lst)#[1, 4, 2, 3]

• extend()

  lst = [1, 2, 3]
  lst.extend([4, 5])#将一个课迭代对象里面的东西迭代进lst
  print(lst)#[1, 2, 3, 4, 5]

• pop()

  lst = [1, 2, 3]
  lst.pop()
  print(lst)#[1, 2]

  lst = [1, 2, 3]
  lst.pop(1) #pop里面可以传参数，参数就是列表的下标,如果不传就默认删除最后一个
  print(lst)#[1, 3]

• remove()

  lst = [1, 2, 3]
  lst.remove(2)#删除这个值是这个参数的元素
  print(lst)#[1, 3]

• clear()

  lst = [1, 2, 3]
  lst.clear()#清空列表里面的所有东西
  print(lst)#[]

• reverse()

  lst = [1, 2, 3]
  lst.reverse()#将列表反转
  print(lst)#[3, 2, 1]

• sort()

  lst = [2, 1, 3]
  lst.sort()#将列表内的数字排序,默认从小到大
  print(lst)#[1, 2, 3]

  lst = [2, 1, 3]
  lst.sort(reverse=True)#加了这个参数就是从大到小排序了
  print(lst)#[3, 2, 1]

• count()

  lst = [1, 2, 3]
  print(lst.count(2))#统计列表中2的出现次数#1

• len()

  • 当然列表也是可以获取它的长度的

    lst = [1, 2, 3]
    print(len(lst))#3

4.5.元组（tuple）

• 什么是元组呢？
  • (1, 2, 3)长这样的就是元组
• 元组和列表有什么区别呢？
  • 列表可以更改，而元组不可以更改，只能查看

4.6.range

• range实际上可以理解为范围

  print(range(6))#range(0, 6)

• 什么？不理解？

  lst = list(range(6))
  print(lst)#[0, 1, 2, 3, 4, 5]

• 理解了吧，当然还有

  lst = list(range(0,6,2))
  print(lst)#[0, 2, 4]

4.7字典（dict）

• 什么是字典？

  • {‘k1‘:‘v1‘, ‘k2‘:‘v2‘}
  • {键:值}
  • 这样的就是字典

  dic = {'k1':'v1', 'k2':'v2'}
  print(dic['k1'])#v1

  • 怎么样好理解吧，要是不理解就自己细品，哈哈哈

• 字典有什么用？

  • 字典其实就是查看里面的数据的
  • 那么有人会说列表，元组都可以啊。
  • 列表元组查元素是从开始到结束一个一个的找的。
  • 而字典就是根据键直接找到值,这样就会很快很快

4.8.集合（set）

• 什么是集合？

  • {1, 2, 3}
  • 长上面那样的就是集合
  • 这个怎么这么眼熟？集合不也是这个吗？
  • 虽然都是大括号，其实两者是有区别的。
  • 集合是一个一个的元素，而字典是key和value成对出现的

• 集合中的元素是不能重复的，要都是可以哈希的，且会自己按顺序排列

  set1 = {2, 3, 3, 1}
  print(set1)#{1, 2, 3}

• add()

  set1 = {1, 2, 3, 4, 5}
  set1.add(6)
  print(set1)#{1, 2, 3, 4, 5, 6}

• pop()

  set1 = {1, 2, 3, 4, 5}
  set1.pop()#随机删除一个
  print(set1)#{2, 3, 4, 5}

  • 我看别人的是随机删除一个
  • 这里是带返回值的，返回删除了的那个
  • 在我使用数字的时候，默认就是删除的最小的那个
  • 但是在用字符串的时候就不一定了，就是随机删除了，这里大家注意一下

• remove()

  set1 = {1, 2, 3 ,4, 5}
  set1.remove(2)
  print(set1)#{1, 3, 4, 5}

• clear()

  set1 = {1, 2, 3 ,4, 5}
  set1.clear()
  print(set1)#set()

  • 咦？你想的是不是输出{}这个东西
  • 为什么不输出这个东西呢？因为空字典是这个东西，为了区分两者

• 集合的一些常用操作

  s1 = {1, 2, 3}
  s2 = {3, 4, 5}
  
  #交集
  print(s1 & s2)#{3}
  print(s1.intersection(s2))#{3}
  
  #并集
  print(s1 | s2)#{1, 2, 3, 4, 5}
  print(s1.union(s2))#{1, 2, 3, 4, 5}
  
  
  #差集
  print(s1 - s2)#{1,2}
  print(s1.difference(s2))#{1,2}
  
  
  #反交集
  print(s1 ^ s2)#{1, 2, 4, 5}
  print(s1.symmetric_difference(s2))#{1, 2, 4, 5}
  
  
  #子集
  print(s1 < s2)#False
  print(s1.issubset(s2))#False
  
  
  #超集
  print(s1 > s2)#False
  print(s1.issuperset(s2))#False

  • • 什么是子集？

    • 如果s1里面的元素s2里面都有，那么s1就是s2的子集，并且还是真子集

  • 什么是超集？

    • 与子集的概念相反
    • 如果s1里面的元素s2里面都有，那么s2就是s1的超集

5.深浅拷贝

• 在说深浅拷贝前我来说一说一些小东西

  • ==

    n1 = 10
    n2 = 10
    print(n1 == n2)#True

  • id(获取变量所指的内存地址的)

    v1 = "nanke33"
    v2 = "nanke33"
    print(id(v1),id(v2))#2040780017936 2040780017936

  • is（判断两个值之间的内存地址是否相同）

    v1 = "nanke33"
    v2 = "nanke33"
    print(v1 is v2)#True

• 浅拷贝

  • 我来创建一个列表lst1 = [1,2,[3,4,[5,6]]]

  • 我们来浅拷贝一下

    lst1 = [1,2,[3,4,[5,6]]]
    lst2 = lst1.copy()
    print(lst2)#[1,2,[3,4,[5,6]]]

  • 是不是没区别,那我们再来操作一下

    lst1 = [1,2,[3,4,[5,6]]]
    lst2 = lst1.copy()
    lst1[0] = 9
    print(lst2)#[1,2,[3,4,[5,6]]]

  • 为啥还是一样呢？

    • 在这里，因为已经拷贝了原来lst1，所以lst1变了，lst2没变
    • 你以为就这么简单？
    • 当然不

  • 我们再来操作一波

    lst1 = [1,2,[3,4,[5,6]]]
    lst2 = lst1.copy()
    lst1[2][1] = 9
    print(lst2)#[1, 2, [3, 9, [5, 6]]]

    • 怎么了？怎么了？
    • 看见没？列表里面的列表的第二个元素变了，它变化了
    • 这是为什么呢？
    • 这是因为浅拷贝只拷贝原来的第一层的值到新的内存，再往深了还是用的lst1的内存地址，所以就会这样。
    • 我们第一次的操作，更改了lst1的第一层，然后lst2已经把第一层的值存到自己的内存地址了，所以lst1的第一层变，lst2不会变。
    • 在我们第二次操作，操作的第二层，lst2在第二层还是引用的lst1的内存地址，所以lst1里面的第二层变了，lst2里面的第二层也会变.
    • 同理，往更深层也依旧会变。

• 深拷贝

  • 我们再来创建一个列表lst1 = [1,2,[3,4,[5,6]]]

  • 我们来深拷贝一下

    import copy
    lst1 = [1,2,[3,4,[5,6]]]
    lst2 = copy.deepcopy(lst1)
    print(lst2)#[1, 2, [3, 4, [5, 6]]]

  • 同样的没有变化，那我们来操作一波

    import copy
    lst1 = [1,2,[3,4,[5,6]]]
    lst2 = copy.deepcopy(lst1)
    lst1[0] = 9
    print(lst2)#[1, 2, [3, 4, [5, 6]]]

  • 和浅拷贝一样，依旧没有变化。

  • 你能想到我下一步是动第二层了，那是不是和浅拷贝一样的结果呢？

    import copy
    lst1 = [1,2,[3,4,[5,6]]]
    lst2 = copy.deepcopy(lst1)
    lst1[2][1] = 9
    print(lst2)#[1, 2, [3, 4, [5, 6]]]

  • 哈哈哈，我猜你已经知道答案了，恭喜你。

  • 那么你是否知道为什么呢？

    • 因为深拷贝把lst1的所有层的值都存到自己的内存地址了，而不是仅仅只拷贝了第一层

6.文件操作

• 首先我有一个1.txt的文件

  123321
  3213123

6.1r

• r

  f1 = open('1.txt',mode='r',encoding='utf-8')
  print(f1.read())
  f1.close()
  #123321
  #3213123

• rb

  f1 = open('1.txt',mode='rb')
  print(f1.read())
  f1.close()
  #b'123321\r\n3213123'

  • 显而易见这里是字节型

• r+

  • 这个是读写模式，就是又可以读又可以写

  f1 = open('1.txt',mode='rb',encoding='utf-8')
  print(f1.read())
  f1.write("321")
  f1.close()
  #123321
  #3213123
  

  • 结果是这样，那我们再看看1.txt里面变成什么样子了

  123321
  3213123321

  • 他变成这样子了
  • 就代表它写成功了

• r+b

  f1 = open('1.txt',mode='r+b')
  print(f1.read())
  f1.write("321")
  f1.close()
  #b'123321\r\n3213123'

  • 来看1.txt

  123321
  3213123321

6.2w

• w

  f1 = open('1.txt',mode='w',encoding='utf-8')
  f1.write("123")
  f1.close()

  • 这里看不到结果
  • 我们去文件里面去看

  123

  • 为啥变成123了，我之前的内容呢？
  • 之前的内容不见了
  • 因为w写模式会在打开文件的时候把原来的数据清空了，然后再写
  • 还有，如果没有1.txt文件，那么它会自己生成一个1.txt文件然后再写。
  • 而r模式就不行

• wb

  • 在这里知道rb了，那wb也应该差不多知道了吧

  f1 = open('1.txt',mode='wb')
  f1.write("123")
  f1.close()
  #报错

  • 为啥会报错了，因为123不是字节型。

  f1 = open('1.txt',mode='wb')
  f1.write(b"123")
  f1.close()

  • 这样就好啦

• w+

  • 先将所有内容清空然后再写入，再读取

  f1 = open('1.txt',mode='w+',encoding='utf-8')
  f1.write("123")
  print(f1.read())#
  f1.close()

  • 啥也没输出，但是却写入了123

• w+b

  • 和w+同理，只是换成字节型了

6.3a

• a

  f1 = open('1.txt',mode='a',encoding='utf-8')
  f1.write("123")
  f1.close()

  123321
  3213123123

  • a模式就是追加

• ab

  f1 = open('1.txt',mode='ab')
  f1.write(b"123")
  f1.close()

  123321
  3213123123

  • 同样

• a+

  f1 = open('1.txt',mode='a+',encoding='utf-8')
  print(f1.read())
  f1.write("123")#
  f1.close()

  • 没东西

• a+b

  • 同理a+，只是读写字节

6.4补充

• 相对路径/绝对路径
  • 相对路径
    • 相对路径就好比一条路线
    • 假设你在一栋教学楼的A教室里，你朋友在B教室里
    • 你要去找他
    • 那么是不是直接出A教室，进入B教室就能找到了
    • 假设你朋友和你都在A教室里，那是不是就不用有路线了，直接就能找到了
  • 绝对路径
    • 还是相对路径的背景
    • 如果有一个不在教学楼的人要来找你朋友
    • 那他进入教学楼，找到B教室就能找到你朋友了
  • 总结
    • 相对路径以你自己为基础，出教室，进入B教室。这样是不是只有在A教室的人，才能根据你的方法找到人
    • 绝对路径不以自己为基础，每个人就都能找到教学楼->B教室->人

• seek()

  • seek()函数就是在文件操作的时候移动光标位置的

  seek(0，0)#移动到开头写成seek(0)也行
  seek(0, 2)#移动到结尾
  seek(0, 1)#表示当前位置
  seek(n)#n>0 表示光标移动几个字节

• tell()

  tell()#就是告诉你当前光标的位置

• readline()

  f1 = open('1.txt',mode='r',encoding='utf-8')
  print(f1.readline())
  f1.close()#123321\n

  f1 = open('1.txt',mode='r',encoding='utf-8')
  print(f1.readline().strip())
  f1.close()#123321

• readlines()

  f1 = open('1.txt',mode='r',encoding='utf-8')
  print(f1.readlines())
  f1.close()#['123321\n', '3213123']

• 大文件如何操作？

  • 在读大文件的时候，如果我们直接读会导致内存崩溃，那我们就一行一行来读

  f1 = open('1.txt',mode='r',encoding='utf-8')
  for line in f1:
      print(line.strip())
  f1.close()
  #123321
  #3213123

• with...as...

  • 我们如果用平常的方法

    f1 = open('1.txt',mode='r',encoding='utf-8')
    f1.close()

  • 这样来组合，我们有的时候说不定就会忘记了，要close，所以我通常使用这种方法，效果是一样的

    with open('1.txt',mode='r',encoding='utf-8') as f1:
        for line in f1:
            print(line.strip())
    #123321
    #3213123

7.写在最后

• 如果你快速浏览了一下，到了这里，那我很幸运。
• 你没有看到一半就走，哈哈哈
• 为什么要写在最后，不写在开头？因为开头谁都能看见，我不好意思。
• 决定开始经常写博客，算是对自己一段时间的学习的知识点的总结，这个是真的可以巩固和复习你学过的内容。
• 我是一个不爱做笔记的人，这样让自己写博客，总结知识点和将自己遇到过的问题都写在博客里，以后还能自己看看。说不定还能帮助到正在遇到这些问题的人。
• 这也是为了避免学了各种语言后就只会输出Hello World了
• 自己学了C、C++、Java、PHP、js的入门级别
• 现在真的就只会Hello World
• 第一次写博客，没有什么经验，现在的想法是以后的博客风格偏向于教会别人，这样让我可以不仅自己明白了，还想着怎么让别人明白，这样对自己的提升还是很大的。
• 当然啦，自己毕竟是个菜鸟，写的东西的水平确实上不了台面，但自己会慢慢努力的。
• 不知道大家有没有这样一个困惑，就是有的时候特别特别不想学习，啥也不想干，代码不想码，游戏不想打，视频不想看。就只想睡觉，还睡不着。。。。。。
• 反正有这个状态的时候学习效率低的吓人，可能学了一天，还比不上我正常学一小时。
• 我感觉这样可能是因为我缺乏锻炼吧，我想如果我有幸让你看到我的博客，那你多半也是个代码dog，要多锻炼锻炼啊
• 我前几天看程序员吐槽大会，主持人最后说的那句话很喜欢，他说是阿里的孤尽说的，但我没找到原文出自哪里
• 我们敲的不是代码
• 是我们读过的书
• 看过的电影
• 听过的音乐
• 走过的路
• 爱过的人
• 反正这篇磨磨唧唧的写了两天，为什么这么久，可能是因为菜吧
• 最后推荐大家去关注一个b站up主，逆风微笑的代码狗。他会每天分享各种教学视频，都是挺不错的视频
• 再到最后，如果有兴趣组个群，一起学习，一起讨论技术的大佬带带我。
• 我QQ：707273429，备注博客就行，当然如果你是个小白决定要变身成代码dog，也可以加我，我会尽我所能的帮助你。
• 加油少年

南柯33的Python学习笔记第（一）部分

原文：https://www.cnblogs.com/nanke33/p/12026759.html