• 欢迎光临~

第二周总结

开发技术 开发技术 2022-10-07 次浏览

周总结

数据的基本类型

整型 int
name = 1
浮点型 float
name = 1.1
字符串 str
name = '1.1'
注释和字符串怎么区分:有赋值符号左边有变量名的就是字符串
列表 list
name = [1, 2, 3]
索引值从0开始
字典 dict
name = {'name':1, 'name2':2,'name3':3}
k:v k是键 v是数据值
k是解释v的
布尔值 bool
Ture Flase
python中的数据值自带布尔值
Flase:{}、[]、''、none、0
剩下的数据值都是Ture
元组 tuple
name = (1, 2, 3, 4)
元组内的数据值不能改变
如果元组内只有一个数据值也要加,
集合 set
name = {1, 2, 3}
{}默认是字典
set{}是集合

与用户交互

1.用户输入
username = input('请输入用户名:')
'''
限执行input获取用户名
给输入的数据绑定一个变量值username
可以反复使用
'''
python2和puython3中的区别
python2中input需要自己指定类型
raw_input 和python3中一样 输出统一处理成字符串
print 数据值
print(数据值)
2.用户输出
print()
括号里可以放变量名也可以放数据值
print自带换行符rn  n
print 也可以切换结束符 
print(数据,end='')


格式化输出

提前定义好 可以局部修改
占位符%s %d

单个占位符
info =' %s同学你好'
print(info % '日日') #日日同学你好
print('%同学你好' % '日日')   #日日同学你好
print(info % ('日日,'))   # 日日同学你好
print('%s同学你好'% ('日日,'))  #日日同学你好
多个占位符
info = 'name = %s age = %s hobby = %s'
print = ('name = %s age = %s hobby = %s'%('sun,22,music'))
有几个占位符就要有几个数据值 多了不行 少了也不行
%s 任何数据类型都支持
%d 支持数字类型

基本运算符

1.数字运算符
+ - * / % // **
2.比较运算符
<== >== == != < >

常用赋值符

1.链式赋值
name1=name2=name3='sun'
2.交叉赋值
m = 1
n = 2
m,n = n,m
print(m,n)

3.解压赋值
name_list = ['sun','rain','sunny']
name1 = name_list[0]
name2 = name_list[1]
name3 = name_list[2]
要保证左边的变量名和右边的数据值个数一致
变量名多、少都不行
'''
当解压的数据值特别多 只用其中的几个时 可以打破上面的规则
'''
a,b* = name_list # 会自动能接受多余的数据 组成列表给b
print(a) # sun
print(b) #['rain','sunny']
a, b*,c = name_list 
print(a) #sun
print(c) #sunny
print(b) #['rain']
数据不准备使用时可以用下划线作为变量名绑定
a,*_,c = name_list

逻辑运算符

and
连接的多个数据值必须都成立 结果才成立
2 > 1 and 3 > 2 and 3 > 1 Ture
如果and左边成立 那么结果取决于右边 右边是数据值 结果就是数据值 右边是表达式 结果就是布尔值
or
连接的多个数据值只要有一个成立 就成立
1 > 2 or 2 = 2 or 3 >1 Ture
not
取反 类似于说反话
print(1=1) Flase

成员运算符

name_list = ['sun','sunny','rain']
print('rir'in name_list) #Flase  riri不在列表里
print('rir' not in name_list) #Ture riri不在列表里
print('s'in nname_list)    #Flsae 列表最小的单位是数据值
name = 'sun'
print('s' in name)    #Ture 字符串中最小的单位是字符
l1 = {'name1':'sun'}
print('sun' in l1)  # Flase 字典中只有键参与 值不参与

身份运算符

id()
'''
返回一串数字 可以看成是内存地址
'''
is 判断内存地址是否相同
== 判断值是否相同
l1 = [11, 22, 33, 44, 55, 66, 77, 88]
l2 = [11, 22, 33, 44, 55, 66, 77, 88]
print(l1 == l2)  # True
print(id(l1))
print(id(l2))
print(l1 is l2)  # False
'''
值相同 内存地址可能不同
内存地址相同 值一定相同
'''

垃圾回收机制

1.引用计数
当数据值身上的计数为0时 就会被垃圾回收机制当成垃圾处理掉
name = 'sun' # sun身上的计数是1
name1 = name #sun身上的计数+1
delname1   # sun 身上的计数-1
2.标记清除
主要针对循环问题
l1 = [11, 22, 33]
l2 = [33, 44, 55]
l1.append l2  #l1 = [11, 22, 33,[l2]]
l2.append l1  #l2 = [33, 44, 55, [l1]]
del l1  #断开l1 与列表的绑定关系 引用计数为1
del l2  #断开l2 与列表的绑定关系 引用计数为1
'''
当内存到达临界点时 程序会自动停止 扫描所有数据 给循环引用的数据打上标记 然后一次性清除
'''
3.分代回收
新生代 青春代 老年代
循环引用次数越多的数据值 越往下 越常用的数据值越不容易被清理掉 检测的时间也会间隔比较长

流程控制理论

分为三种
1.顺序结构
从上往下依次运行
2.分支结构
根据不同的条件做出不同的执行策略
3.循环结构
会根据某个命令重复出现
'''经常出现3者混合'''
4.python中用缩进来表示从属关系
子代码是否之执行取决去上面没有所进的代码
5.不是所有代码都能拥有子代码
if while
6.如果一个父代码有多个子代码 那么所有子代码的缩进要一样
7.父代码要带冒号
8.相同缩进的代码平起平坐 按顺序依次进行

分支结构

1.单if分支结构
if条件:
  成立以后才会执行代码
2.if...else
if条件:
  成立以后执行子代码
else:
  条件不成立执行子代码
3.if...elif...else
if条件1:
    条件1成立后执行子代码
elif条件2:
    条件1不成立 条件2成立后执行子代码
elif条件3:
    条件1不成立 条件2不成立 条件3成立后执行子代码
else:
    上述条件都不成立 执行子代码
'''elif 可以有多个 上述子代码只能有一个 '''
4.if 的嵌套
if.....:
  print()
    if.....:
      elif...
        print()
     else:
        print()
else: 
   print() 

循环结构

while条件:
   条件成立后执行子代码(循环体代码)
1.先判断条件是否成立
2.成立执行子代码
3.执行完返回条件判断处 判断是否成立
4.成立继续执行
5.直到条件不成立 结束循环体代码
6.强制结束:
break
while执行到break就会强制结束循环
跳过条件判断处:
7.continue
while执行到continue就会返回条件判断出开始新的循环
8.while...else
while条件:
   循环体代码
else:
  循环体没有被强制结束的情况下执行完毕就会执行else的子代码
9.死循环
  死循环 会使cpu的功耗急剧上升 知道系统采取紧急措施
10.嵌套及全局标志位
break只能结束他所在的那一层的循环
如果想一次性结束 要就要有几个while就要有几个break
如果不想写那么多break可以用全局标志位

for循环

for 能做的whil都能做 在一些场景中 for比while更简单
for 变量名 in 待遍历的数据:
      for 循环体代码
for循环的特点:
1.擅长遍历取值
2.不需要结束条件 遍历完直接结束
for循环主要遍历的数据类型(字符串、列表、元组、字典、集合)
for循环在字典中 只有键参与遍历
for循环语法中不需要预先设置索引变量
for循环语法结构中的变量名如何让命名:
1.见名知意
2.如果遍历出来的数据值没有具体含义 可以用j、k、v等来命名
for循环中执行到break也会直接结束整个for循环
for 变量名 in 待遍历的数据:
  for循环体代码
else:
  循环体没有被强制结束的情况下执行完毕就会执行else的子代码

range方法

1.range 可以简单理解为是帮我们产生一个内部含有多个数字的数据
for i in range(101):  #起始位置是0 终止位置是100
   print(i)  # [0,....,100]
for i in range(10,20):#起始位置是10 终止位置是20
   print(i)  #[10,11,...,20]
for i in range(1,10,2) #第三个数为等差值
   print(i)  #[1,3,5,7,9]
2.range 在python2和python3中的区别
python2
  range()
    直接产生一个列表 里面包含所有数值
  xrange()
    和python3中的range一样
python3
    类似于一个工厂 不会占用太多空间 你用什么数据生产什么数据
3.range实战
    网络爬虫
     用代码在网络上爬取我们所需要的内容
    都是有规律的

数据类型的内置方法:

整型:
1.类型转换
  int(其他数据类型)
ps:浮点型可以直接转换 字符串必须满足内部是纯数字
2.进制数转换
print(bin(300))   #二进制
print(oct(300))   #八进制
print(hex(300))   #十六进制
''' 0b 二进制 0o八进制  0x十六进制'''
其他方式转十进制:
方式一
print(int(0b1000101100)) 
print(int(0o454))
print(int(0x12c))
方式二
print(int('0b1000101100',2))
print(int('0o454',8))
print(int('0x12c',16))
3.python自身对数字的敏感度比较低
  如果需要精准计算 可以借用模块

浮点型类型的内置方法:

1.类型转换
   float(其他数据类型)
   字符里面只允许出现一个小数点 其他必须是纯数字
2.python自身对数字的敏感度比较低
    如果需要精准计算 可以借用模块

字符串类型的内置方法:

1.类型转换
   str.(其他数据类型)
   可以转换任意数据类型 只要加上引号

2.索引取值(起始是0 超出范围直接报错)
    q1 = '今天天气真好'
    print(q1[0])     # 今
    print(q1[-1])    # 好 支持负数 从末尾开始数
    
3.切片操作
    print(q1[0:2])    #从索引0一直切取到2
    print(q1[-1:-5])  #打印不出来 因为默认顺序是从左往右的
    print(q1[-5:-2])  #默认顺序是从左往右
    
4.修改切片方向(间隔)[::]
    print(q1[1:4:1])    #最后一个数字默认是1
    print(q1[1:4:2])    #最后一个数字的意义是几就隔几切
    print(q1[-1:-6:-1]) #从后往前切
    print(q1[:])        #不写数字默认都要
    print(q1[2:])       #从索引2开始后面的都要
    print(q1[:4])       #从索引0开始往后到4
    print(q1[::3])      #从索引0开始 每3个取一个
    
5.统计字符串中字符的个数 len()
    print(len(q1))        #6
    
6.移除字符串首尾指定的字符 .strip()
    username = input('username>>>:').strip()
    username = username.strip()
    if username == 'sun':
        print('666')
    res = 'sun'
    print(len(res))
    print(len(res.strip()))  #括号内不写 默认移除首尾空格
    res1 = '**sun**'
    print(res1.strip('*'))   # sun 去掉*
    print(res1.lstrip('*'))  # sun** 去掉左边的*
    print(res1.rstrip('*'))  #**sun  去掉右边的*
    
7.切割字符串中指定的字符.split()
    res = 'sun|123|music'
    print(res.split('|'))           # ['sun', '123', 'music'] 处理完是一个列表
    name, pwd, hobby = res.split('|')
    print(res.split('|',maxsplit=1))   #从左往右切指定个数
    print(res.rsplit('|',maxsplit=1))  #从右往左切指定个数
    
8.字符串格式化输出 .foemat()
format玩法1:等价于占位符
     res = 'my name is {} my age is {}.format( sun, 123) '
     print(res)
format玩法2:索引取值并支持反复使用
     res = 'my name is {0} my age is {1}'.format('sun', 22)
     print(res)
format玩法3:占位符见名知意
     res = 'my name is {name1} my age is {age1}'.format(name1='sun', age1=123)
     print(res)
format玩法4:推荐使用
     name=input('请输入姓名>>:')
     age=input('请输入年龄>>:')
     res = f'my name is {name} my age is {age}'
     print(res)    

字符串需要了解的方法:
1.大小写  大写.upper()  小写.lower()
     res='hellO worD666'
     print(res.upper())      #  HELLO WORD666 全大写
     print(res.lower())      #  hello word666 全小写
    '''
      图片验证码:生成没有大小写统一的验证码展示给用户看
      获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转成大写或小写再比对
    # '''
      code = 'fhUDn'
      print('展示给用户看的图片验证码',code)
      confirm_code = input('请输入验证码').strip()
      if confirm_code.upper() ==code.upper():
          print('验证码正确')
      res = 'hello world'
      print(res.isupper())  # 判断字符串是否是纯大写 False
      print(res.islower())  #判断字符串是否是纯小写 True
    
2.判断字符串中是否是纯数字 .isdigit()
      res = ''
      print(rss.isdigit())
      guess_age = input('guess_age>>>:').strip()
      if guess_age.isdigit():
          guess_age = int(guess_age)
      else:
        print('年龄都不会写吗')
        
3.替换字符中所指定的内容 .replace
      res='my name is sun'
      print(res.replace('sun','rain'))     # my name is rain 替换
      print(res.replace('sun', 'rain', 1)) #my name is rain 从左往右替换指定个数内容
4.字符串的拼接 .join()
      aa1 = 'hello'
      aa2 = 'word'
      print(aa1 +aa2)            #helloword
      print(aa1 * 10)        #hellohellohellohellohellohellohellohellohellohello
      print('|'.join(['sun','666','music']))  sun|666|music 拼接的字符必须是字符串
    
5.统计指定字符出现的次数 res.count
      res = 'sun say hello'
      print(res.count('l'))   #2 l出现了2次
6.判断字符串的开头或结尾 .startswith('')
          res = 'sun say hello'
    print(res.startswith('sun'))     # Ture
    print(res.startswith('su'))      # Ture只能从第一个字母前往后取
    print(res.startswith('un'))      # False 不能从中间取
    print(res.endswith('o'))         # Ture 从后往前取
    print(res.endswith('ol'))        # False 从后面取也要按照从左往右的顺序取
    print(res.endswith('ll'))        # False 不能在中间取
    print(res.endswith('lo'))        # Ture  按顺序从左往右取

7.其他方法补充
     res = 'helLO wORld hELlo worLD'
     print(res.title())  # Hello World Hello World
     print(res.capitalize())  # Hello world hello world
     print(res.swapcase())  # HELlo WorLD HelLO WORld
     print(res.index('O'))
     print(res.find('O'))
     print(res.index('c'))  # 找不到直接报错
     print(res.find('c'))  # 找不到默认返回-1print(res.find('LO'))  # 3

列表内置方法及操作:

1.类型转换
    list(其他数据类型)
    ps:能够被for循环的数据类型都可以转成列表
    print(list('hello'))                     # ['h', 'e', 'l', 'l', 'o']
    print(list({'name':'sun','pwd':'666'}))  # ['name', 'pwd']
    print(list((1, 2, 3, 4)))                # [1, 2, 3, 4]
    print(list({1, 2, 3, 4, 5}))             # [1, 2, 3, 4, 5]
需要掌握的方法
1.索引取值(正负数)
     1 = [11, 22, 33, 44, 55, 66,]
     print(l1[0])      # 11 从左往右取值
     print(l1[-2])     # 55 从右往左取值    
    
2.切片操作
     print(l1[0:5])    # [11, 22, 33, 44, 55] 取前5个数
     print(l1[:])      # [11, 22, 33, 44, 55, 66] 只有冒号 全都要
        
3.间隔数 方向
     print(l1[::-1])    # [66, 55, 44, 33, 22, 11] 
    
4.统计列表中数据的个数
     print(len(l1))     #6
    
5.数据值修改
    l1[0]=123
    print(l1)            # [123, 22, 33, 44, 55, 66] 把索引值为0的数值改成123
    
6.列表添加新数据
方式1:尾部追加数据值
     l1.append('hhaha')     #  [11, 22, 33, 44, 55, 66, 'hhaha'] 在尾部加上hahaha
     print(l1)
     l1.append('[11,22,]')    #  [11, 22, 33, 44, 55, 66, '[11,22,]'] 可以在尾部加上列表
     print(l1)
方式2:任意位置插入数据值
     l1.insert(0,'sun')
     print(l1)                 #  ['sun', 11, 22, 33, 44, 55, 66] 在索引值为0的前面加sun
     l1.insert(2,[666,999])
     print(l1)                 # [11, 22, [666, 999], 33, 44, 55, 66] 在索引值为2的前面加上列表
方式3:扩展列表 合并列表
     ll1=[11,22,33]
     ll2=[44,55,66]
     print(ll1+ll2)             # [11, 22, 33, 44, 55, 66] 将列表拆分然后再合并两个列表
     ll1.extend(ll2)            # for循环+append
     print(ll1)                 # [11, 22, 33, 44, 55, 66]
     for i in ll2:                # [11, 22, 33, 44]    ll1每循环一次加一个ll2里面的数值
     ll1.append(i)            # [11, 22, 33, 44, 55]
         print(ll1)               # [11, 22, 33, 44, 55, 66]
        
7.删除列表数据
方式1:通用的删除关键字del
     del l1[0]
     print(l1)                      #[22, 33, 44, 55, 66] 删掉索引值为0的数据值
方式2:remove
     l1.remove(11)
     print(l1)                         #[22, 33, 44, 55, 66] 括号里填写要删掉的数据值
方式3:pop
     l1.pop(1)
     print(l1)                         #[22, 44, 55, 66] 括号里要填写删掉的数据的索引值
     l1.pop()
     print(l1)                           # [11, 22, 33, 44, 55] 默认尾部弹出数据值
     res=l1.pop(2)
     print(res)                         # 33 弹出索引值为2的数字
     res1 = l1.remove(33)
     print(res1)  
8.排序
     ss=[55,22,66,22,66,51,34,67,984]
     ss.sort()                            # 默认是升序
     print(ss)                            # [22, 22, 34, 51, 55, 66, 66, 67, 984]
     ss.sort(reverse=True)                # 改为降序
     print(ss)                            #[984, 67, 66, 66, 55, 51, 34, 22, 22]
    
9.统计列表中某个数据值出现的次数
     print(l1.count(22))                  # 1 22在列表l1中出现了1次
10.颠倒列表顺序
     l1.reverse()
     print(l1)                            #[66, 55, 44, 33, 22, 11]

字典必须要掌握的操作:

1.按k取值
    print(user_dict['username']) # jason
    print(user_dict['phone'])  # k不存在会直接报错
2.按内置方法get取值
    print(user_dict.get('username'))   # jason
    print(user_dict.get('age'))        # None
    print(user_dict.get('username','嘿嘿'))  # jason 键存在的情况下 获取 对应的值
    print(user_dict.get('age','嘿嘿'))       # 嘿嘿 键不存在的情况下默认返回None 可以通过第二个参数自定义
3.修改数据值
	user_dict['age'] = 18                # 键不存在 则新增键值对
    print(user_dict)   
4.新增键值对
    user_dict['age'] = 18  # 键不存在则新增键值对
    print(user_dict)
5.删除数据
    del user_dict['username']
    print(user_dict)                     # {'password': 123, 'hobby': ['read', 'music', 'run'], 'age': 18}
    res = user_dict.pop('password')
    print(res)                           # 123
6.统计字典中键值对的个数
	print(len(user_dict))                  # 3
7.字典三剑客
    print(user_dict.keys())                #dict_keys(['username', 'password', 'hobby']) 一次性获取字典所有的键
    print(user_dict.values())              #dict_values(['jason', 123, ['read', 'music', 'run']])一次性或取字典的所有值
    for i in user_dict.items():              #username jason      提取字典里的k,v值
        k,v = i                              #password 123
        print(k,v)                           #hobby ['read', 'music', 'run']
8.补充说明
    print(dict.fromkeys(['name', 'pwd', 'hobby'], 123))  # 快速生成值相同的字典
    res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
    print(res)  # {'name': [], 'pwd': [], 'hobby': []}
    res['name'].append('jason')
    res['pwd'].append(123)
    res['hobby'].append('study')
    print(res)
    '''
    当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有
    '''
    res = user_dict.setdefault('username','tony') # 键存在则不修改 结果是键对应的值
    print(user_dict,res)         # {'username': 'jason', 'password': 123, 'hobby': ['read', 'music', 'run']} jason
    res = user_dict.setdefault('age',123)     #键不存在 则新增键值对 结果是新增的值
    print(user_dict)           #{'username': 'jason', 'password': 123, 'hobby': ['read', 'music', 'run'], 'age': 123}
    user_dict.popitem()  # 弹出键值对 后进先出

元组相关操作:

1.类型转换
	tuple()
 	ps:支持for循环的数据类型都可以转成元组
2.元组必须掌握的方法
	t1 = (11, 22, 33, 44, 55, 66)
    1.索引取值
    2.切片操作
    3.间隔、方向
    4.统计元组内数据值的个数
     print(len(t1))  # 6
    5.统计元组内某个数据值出现的次数
     print(t1.count(11))
    6.统计元组内指定数据值的索引值
     print(t1.index(22))
    7.元组内如果只有一个数据值那么逗号不能少
    8.元组内索引绑定的内存地址不能被修改(注意区分 可变与不可变)
    9.元组不能新增或删除数据

集合相关操作:

1.类型转换
    set()
	集合内数据必须是不可变类型(整型 浮点型 字符串 元组)
 	集合内数据也是无序的 没有索引的概念
2.集合需要掌握的方法  
    去重
 	关系运算
	ps:只有遇到上述两种需求的时候才应该考虑使用集合
3.去重
s1 = {11, 22, 11, 22, 22, 11, 222, 11, 22, 33, 22}
 	 l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
    s1 = set(l1)
    l1 = list(s1)
    print(l1)
 	'''集合的去重无法保留原先数据的排列顺序'''
4.关系运算
    群体之间做差异化校验
 	eg: 两个微信账户之间 有不同的好友 有相同的好友
 	 f1 = {'jason', 'tony', 'jerry', 'oscar'}  # 用户1的好友列表
    f2 = {'jack', 'jason', 'tom', 'tony'}  # 用户2的好友列表
     1.求两个人的共同好友
     print(f1 & f2)  # {'jason', 'tony'}
     2.求用户1独有的好友
     print(f1 - f2)  # {'jerry', 'oscar'}
     3.求两个人所有的好友
     print(f1 | f2)  # {'jason', 'jack', 'tom', 'tony', 'oscar', 'jerry'}
     4.求两个人各自独有的好友
     print(f1 ^ f2)  # {'oscar', 'tom', 'jack', 'jerry'}
     5.父集 子集
    print(f1 > f2)
    print(f1 < f2)

可变类型与不可变类型:

s1 = '**sun**'l1 = [11,22,33]s1.strip('*')print(s1)'''字符串在调用内置方法之后并不会修改自己 而是产生一个新的结果如何让查看调用方法之后有没有新结果 可以在调用该方法的代码左侧添加变量名和变量符号res = s1.strip('*')'''
# ret = l1.append(44)# print(l1)  # [11, 22, 33, 44]# print(ret)  # None
'''列表在调用内置方法之后修改的就是自身 并没有产生一个新的结果'''
# 可变类型:值改变 内存地址不变# l1 = [11, 22, 33]# print(l1)# print(id(l1))# l1.append(44)# print(l1)# print(id(l1))​
# 不可变类型:值改变 内存地址肯定变
res = '$$hello world$$'print(res)print(id(res))res.strip('$')print(res)print(id(res))v​
## 字典的相关操作

### 1.类型转换

​```python
dict()
字典的转化一般不使用关键字 而是自己动手转换

字符编码理论:

该知识点理论特别多 但是结论很少 代码使用也很短
1.字符编码只针对文本数据
2.回忆计算机内部存储数据的本质
3.既然计算机内部只认识01 为什么我们却可以敲出人类各式各样的字符
	肯定存在一个数字跟字符的对应关系 存储该关系的地方称为>>>:字符编码本
4.字符编码发展史
	4.1.一家独大
    	计算机是由美国人发明的 为了能够让计算机识别英文
    	需要发明一个数字跟英文字母的对应关系
		ASCII码:记录了英文字母跟数字的对应关系
        	用8bit(1字节)来表示一个英文字符
            
 	4.2.群雄割据
    	中国人
        GBK码:记录了英文、中文与数字的对应关系
       	 	用至少16bit(2字节)来表示一个中文字符
            	很多生僻字还需要使用更多的字节
           英文还是用8bit(1字节)来表示
       日本人
    	  shift_JIS码:记录了英文、日文与数字的对应关系
    	韩国人
         Euc_kr码:记录了英文、韩文与数字的对应关系
  		"""
  		每个国家的计算机使用的都是自己定制的编码本		
  			不同国家的文本数据无法直接交互 会出现"乱码"
  		"""
  	4.3.天下一统
    	unicode万国码
        	 兼容所有国家语言字符
  			  起步就是两个字节来表示字符 
  		utf系列:utf8 utf16 ...
            专门用于优化unocide存储问题
            英文还是采用一个字节 中文三个字节
字符编码实操:
1.针对乱码不要慌 切换编码慢慢试即可
2.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
        字符串.encode()
 	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
        bytes类型数据.decode()
3.python2与python3差异
	python2默认的编码是ASCII
		1.文件头
        	# encoding:utf8
    	2.字符串前面加u
        	u'你好啊'
 	python3默认的编码是utf系列(unicode)
程序员灯塔
转载请注明原文链接:第二周总结
喜欢 (0)
违法和不良信息举报电话:022-22558618 举报邮箱:dljd@tidljd.com