从入门到自闭之python初识

Day 01

整型:

  1. 对比:

    • 在python 2 版本中有整型,长整型long
    • 在python 3 版本中全部都是整型
  2. 用于计算和比较

  3. 整型和布尔值的转换

    • 二进制转换成十进制:

      • ​print (int("111010100",2))

      • python

        2进制 - 10进制

        0 * 20 + 1 * 2 ** 1 + 1 * 22 + 1* 2**3 + 1 * 2 ** 4 + 1 * 2 ** 5
        0 + 2 + 4 + 8 + 16 + 32 = 62
        print(int("111110",2))

    • 十进制转换成二进制:

      • print(bin(30))

      • python

        10进制 - 2进制

        30 0
        15 1
        7 1
        3 1
        1 1
        11110
        print(bin(30))

  4. 整型中只要是非零的就是True

  5. 在布尔值中:1--True,0--False

  6. 在字符串中的内容非空就是True

    1. int,str,bool
      a = bool(0)
      print(a)
      
      a = int(True)
      print(a)
      
      a = int(False)
      print(a)
      
      a = bool("a")
      print(a)
      
      a = bool("啊")
      print(a)
      
      a = bool(" ")
      print(a)
      
      a = bool("")
      print(a)
      
      a = str(True)
      print(type(a),a)
      
      a = str(False)
      print(type(a),a)
      

字符串详解:

  1. 索引(下标):

    1. 从左往右,开头为0

    2. 从右向左,结尾为-1

    3. 索引的条件不能超出索引本身最大值

      a = "alex_wu_sir,_tai_bai_日魔"
      print(a[5])
      print(a[6])
      print(a[11])
      print(a[-2])
      print(a[-1])
      
  2. 切片:

    1. [起始位置:终止位置]----原则:顾头不顾尾

    2. 终止位置可以超出索引本身

    3. [::-1]----从头到尾字符串反转

      a = "alex_wu_sir,_tai_bai_日魔"
      print(a[21:100])
      print(a[21:])  [21(起始位置):(默认到最后)]
      print(a[:])    [(默认从最开始):(默认到最后)]
      print(a[0:-2])
      
  3. 步长:

    1. 步长决定了查找时迈的步子

    2. 步长决定了查找的方向

    3. [起始位置:终止位置:步长]

    4. [::-1]----从头到尾字符串反转

      name = "alex,wusir,太白金星,女神,吴超"
      1.太金
      print(name[11:15:2])
      2.神女
      print(name[-4:-6:-1])
      3.星白
      print(name[-7:-13:-2])
      4."alex,wusir,太白金星,女神,吴超" 整体反转
      print(name[::-1])
      ***** 面试题的答案print(name[10:10000:200000])
      

字符串的方法

  1. upper()--全部大写

  2. lower()--全部小写

  3. startswith()--以……开头

  4. endswith()--以--结尾

  5. replace()--把……替换成……

  6. count()--统计字符出现的次数

  7. strip()--脱(删除前后出现的空白)

  8. split()--分割(默认空格,换行符\n,制表符\t)

  9. format()--字符串格式化,填充

    1. name = "{}今年:{}".format("宝元",18)    # 按照位置顺序进行填充
    print(name)    
    输出:宝元今年:18
    2. name = "{1}今年:{0}".format("宝元",18)    # 按照索引进行填充print(name)    
    输出:18今年:宝元
    3. name = "{name}今年:{age}".format(name="宝元",age=18)    
    # 按照名字进行填充print(name)    
    输出:宝元今年:18
    
  10. isdigit()--判断字符串中的内容是否全是数字

  11. isdecimal()--判断是不是十进制数

  12. isalnum()--判断是不是数字,字母,中文

  13. isalpha()--判断是不是字母,中文

for 循环

  1. for:关键字
  2. i : 变量名(可以随意更改)
  3. in :关键字
  4. msg:可迭代对象(python数据类型中,除了int,bool其余都可以迭代)

Day 02

列表

数据类型之一,存储数据,大量的,存储不同类型的数据

列表是一种有序的容器 支持索引

列表是一种可变数据类型 原地修改

列表中只要用逗号隔开的就是一个元素,字符串中只要是占一个位置的就是一个元素

1.1 列表的增加:

  • lst.append() 追加(在最末尾的地方进行添加)
  • lst. insert() 插入
  • lst.extend() 迭代添加

1.2 列表的删除

  • lst.clear() 清空
  • lst.pop() 删除
  • lst.remove() 移除
del lst[4]    # 通过索引删除
del lst[2:5]    # 通过切片删除
del lst[1:5:2]      # 通过步长删除
print(lst)

1.3 列表的修改:

  • 通过索引进行修改:
lst = [1,2,3,4,5]
lst[2] = 80    通过索引进行修改
print(lst)

  • 通过切片进行修改:

    lst = [1,2,3,4,5]
    lst[1:3] = "20"     # 通过切片进行修改,默认步长为1,修改的内容必须是可迭代的对象,修改的内容可多可少
    print(lst)
    
    
    
  • 通过步长进行修改:

lst = [1,2,3,4,5]
lst[1:5:2] = 100,100    # 步长不为1的时候,必须一一对应
print(lst)


1.4 列表的查:

​ 使用for 循环索引

lst = [1,2,3,4,5]
for i in lst:
	print(i)

1.5 列表的嵌套:

lst = [1,2,[3,4,5,["alex[]",True[[1,2,]],90],"wusir"],"taibai"]
lst1 = lst[2]   
[3, 4, 5, ['alex[]', True, [[1, 2]], 90], 'wusir']
lst2 = lst1[3]  
['alex[]', True, [[1, 2]], 90]
str_1 = lst2[0]
print(str_1[-1])


print(lst[2][3][0][-1])

结果:输出"alex[]"的右边的中括号

元组

2.1 关键字及特性:

  • 关键字:tuple
  • 特性:有序、不可变
  • 格式:(1,2,3) #使用圆括号以及逗号分隔开

2.2 元组的方法:

  • 元组支持查询,元组就是一个不可变的列表

  • 方法:统计、获取索引

    tu = (1,2,3,4,5,1,2,1)
    print(tu.count(1))   # 统计tu元组中“1”的个数
    
    
    tu = (1,2,3,4,5,1,2,1)
    print(tu.index(2))  # 通过元素查询索引“2”的位置
    
    

2.3 元组的用途:

在配置文件中使用

2.4 元组的嵌套:

tu = (1,2,3,4,(5,6,7,8,("alex","wusir",[1,23,4])))
print(tu[4][4][0])

结果:“alex”

range 范围

3.1 用途:为了解决不能循环数字、

3.2 range中py2与py3 的区别:

print(range(1,10)) Python3中打印range是自己range自己本身

print range(1,10) Python2中打印range获取的是一个列表,列表的元素是1-9

3.3range方法:

range(1,10)      [起始位置:终止位置]  顾头不顾尾
range(1,10,2)    [起始位置:终止位置:步长] 默认为 1
range(10)      10代表的是终止位置,起始位置默认为 0range是一个可迭代对象

for i in range(2,10,2):
print(i)      # 输出2 4 6 8 

for i in range(100,-1,-1):
print(i)       # 输出100-0

Day 03

字典:

  1. 定义:dict

  2. dict = {"key":"value"} -- 键值对

  3. 作用:存储大量数据,数据和数据起到关联作用

  4. 所有的操作都是通过键来完成

  5. 键:必须是不可变的数据类型(可哈希),且唯一不可变

  6. 值:任意的数据类型

  7. 字典是可变的数据类型,无序的

  8. 字典的增:

    1. 暴力添加:dict["key"] = "value"

      • 添加一个键值对,可以是列表
    2. 有责添加,无则不添加

      • dict。setdefault(“key”,“value”)

         dic = {
                "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
                "炮手":"飞机",
                "豹哥":"贴膏药",
                "宝元":"宝剑",
                "alex":"吹牛逼"
         }
        dic.setdefault("元宝",["唱","跳","篮球","喝酒"]) 
        print(dic)
        
        
      • setdefault分为两步:

        • 先查看键是否在字典中
        • 不存在的时候进行添加
  9. 字典的删

    1. dict.pop() -- pop删除字典中的键进行删除,返回的也是删除的值
    2. dic.popitem() -- 随机删除 python3.6是删除最后一个
    3. dict.clear()-- 清空
    4. del dict -- 删除的是整个容器
    5. del dic["key"] -- 通过键进行删除
  10. 字典的改

    1. dic["key"] = "value" -- 有则覆盖,无则添加
    2. dict.update() --- 当update中的字典里没有dic中键值对就添加到dic字典中,如果有就修改里边对应的值
  11. 字典的查

    1. dict.get("key") -- 查询不到就返回None

    2. dic.get("key","定制内容") --- 查找不到就返回自己输入的定制内容

    3. dict.setdefault("key") --- 查询不到返回None

    4. dict.["key"] -- 查询不到就报错

    5. 查看所有的键

      for i in dic:   # 查看所有的键    
      print(i)
      
      
    6. 查看所有的值

      for i in dic:   # 查看所有的值   print(dic.get(i))
      
      
    7. 获取到的是一个高仿列表

      print(dic.keys())   # 获取到的是一个高仿列表
      print(dic.values()) # 获取到的是一个高仿列表
      
      
    8. 高仿列表支持迭代,不支持索引

      面试题:    
           a = 10    
           b = 20    
           a,b = b,a    
           print(a)    
           print(b)
      
      
          dic = {"key1":2,"key2":4}
          a,b = dic
          print(a)
          print(b)
      
      
  12. 解构的作用:

    1. 两个都是列表的时候才可以相加

      lst = [1,2,3,4,5,6,7,8]
      lst1 = lst[:2]         
      两个都是列表的时候才能够相加 lst1.append(lst[4])
      for i in lst1:
      print(i)
      
      
    2. *是万能接受

    3. lst = [1,2,3,4,5,6,7,8]
      a,b,c,d,e,*aa = lst     # *是万能接受print(a,b,e)
      
      
    4. 字典嵌套查找的时候一定是按照键一层一层进行查

Day 04

小数据池

  1. int: -5~256
  2. str:
    1. 字母,数字长度任意符合驻留机制
    2. 字符串进行乘法时总长度不能超过20
    3. 特殊符号进行乘法时只能乘以0

代码块:

一个py文件,一个函数,一个模块,终端中的每一行都是代码块

  1. int:-5~无穷大
  2. str:
    1. 定义字符串的时候可以是任意的
    2. 字符串(字母,数字)进行乘法时总长度不得超过20
    3. 特殊字符(中文,符号)进行乘法时乘以0或者1
  3. bool:
    1. True
    2. False

is是判断两边的内存地址是否相同

==判断两个值是否相等

代码块、小数据池同在的情况下先执行代码块。

驻留机制:节省内存空间,提升效率(减少了开辟空间和销毁空间的耗时)

集合

  1. 集合是python中的数据类型之一

  2. 定义方式:set

    • 集合就是一个没有值的字典
  3. 字典的值:唯一,不可变

  4. 集合:无序,可变

  5. 集合天然去重

    # s = {1,23,4,2,1,2,3,1}
    print(s)
    输出结果:{1, 2, 3, 4, 23}
    
    
    # 面试题:
    lst = [1,223,1,1,2,31,231,22,12,3,14,12,3] print(list(set(lst)))
    输出结果:[1, 2, 223, 3, 231, 12, 14, 22, 31]
    
    
  6. s = {} #空字典

    s = set() #空集合

  7. 增:

     s = set()    
    
    s.add("alex")   #直接添加,
    
    输出结果为:{'alex'}    
    
     s.update("wusir")   #迭代添加,
    
    输出结果为:{'r', 'i', 'w', 's', 'u'}    
    
     set("wusir")    #迭代添加,
    
    输出结果为:set()
    
    
  8. s = {100,0.1,0.5,1,2,23,5,4}
    s.remove(4)    # 通过元素删除
    print(s)
    s.clear()  # 清空
    s.pop()      # 随机删除 (最小的)
    print(s)
    
    
  9. 改:

    • 先删后加
  10. 查:

    • for 循环
  11. 其他操作:

    1. 差集--“-”
    2. 交集--“&”
    3. 并集--“|”-管道符
    4. 反交集--“^”
    5. 子集--“>”返回的是一个布尔值
    6. 父集(超集)--"<"返回的是一个布尔值
    7. 冻结集合:frozenset()

深浅拷贝

  1. ​ 赋值:将多个变量指向一个同一个内存地址就是赋值

  2. 浅拷贝:

    1. 只拷贝第一层元素的地址,只有修改第一层的时候元数据不受影响

    2. 给可变数据类型进行添加的时候源数据会受影响

    3. = 是修改,.append是添加

    4. 可变数据类型能够添加和修改,不可变数据类型只能修改

      a = [1,2,3,[4,5]]
      b = a[:]  # 浅拷贝
      print(id(a[-1][0]))
      print(id(b[-1][0]))
      a.append(9)   
      print(a)
      print(b)      
      
      
      a = [1,2,3,[4,5,6,[9,10]],67]
      b = a  # 赋值
      b = a[:]
      a[-2].append(10)#[1, 2, 3, [4, 5, 6, [9, 10], 10], 67]
      a[-2][-1].append(10)#[1, 2, 3, [4, 5, 6, [9, 10, 10]], 67]
      print(b)
      
      
  3. 深拷贝:不可变数据类型内存地址共用,可变数据类型新开辟一个空间

    # import copy  # 导入 copy模块
    a = [1,2,3,[4,5],6]
    b = copy.deepcopy(a)
    print(id(a[-2]))#2812949845896
    print(id(b[-2]))#2812949847304
    print(a)
    print(b)
    print(a == b)		#True
    print(id(a),id(b))
    print(a is b)		#False
    
    

可变数据类型:list(列表),dict(字典),set(集合)

不可变数据类型:int(整型),str(字符串),tuple(元祖),bool(布尔值)

Day 05

基础数据了类型补充:

  1. 字符串:str

    1. 首字母大写:capitalize
    2. 每个单词的首字母大写:.title()
    3. 大小写转换:.swapace()
    4. 居中及填中:.center(数字,''参数'')
    5. 居中:.center(数字)
    6. 查找:.find()--通过元素查找索引,查找不到时返回-1
    7. 查找:.index()--通过元素查找索引,查找不到时报错
    8. 列表+列表 str + str
    9. 列表相乘 str * 5
    10. 字符串相加或者相乘,都是开辟一块新的空间
  2. 列表:list

    1. 通过元素查找索引:.index()

    2. 排序:

      1. .sort()--默认从小到大,升序
      2. .sort(reverse = True)-- 降序
    3. 人工降序:

      lst = [1,23,4,5,7,8,9]
      lst.sort()
      lst.reverse()             #人工降序     print(lst)
      
      
    4. 反转:.reverse()

      反转:.reverse()
      lst = [1,23,4,5,7,8,9]         lst.reverse()
      print(lst)          # 将源数据进行反转
      
      
    5. 不修改元数据进行反转:

      lst = [1,23,4,5,7,8,9]
      lst1 = lst[::-1]
      print(lst)
      print(lst1)        # 不修改源数据进行反转
      
      
    6. 列表相加:

      lst = [1,2,3,4]
      lst = lst + [1,2,3]
      print(lst)  # [1,2,3,4,[1,2,3],]   [1,2,3,4,1,2,3]
      
      
    7. 列表相乘:列表进行乘法运算时,元素是共用的

      lst = [1,2,3] * 5
      print(lst)             print(id(lst[0]),id(lst[3])
      
      
  3. 元祖:tuple

    tu = (1,[]) * 3
    print(tu)    #输出结果:(1, [], 1, [], 1, []) tu[-1].append(10)
    print(tu)  #输出结果:(1, [10], 1, [10], 1, [10])
    
    
  4. 字典:dict

    1. dict.popitem() 随机删除,3.6版本默认删除最后一位

      dic = {}
      dic.fromkeys("abc",[])   # 批量创建键值对 "a":[],"b":[],"c":[]
      print(dic)             #输出的结果为:{}
      
      
      dic = {}
      dic = dic.fromkeys("abc",[])
      print(dic)
      dic["b"] = 11
      dic["a"].append(10)
      print(dic)          
      输出结果为:{'a': [10], 'b': 11, 'c': [10]}
      
      
    2. fromkeys第一个参数必须是可迭代对象,程序会将可迭代对象进行迭代成为字典的键,第二个参数是值(这个值是共用的)

    3. fromkeys 共用的值是可变数据类型就会有坑,不可变数据类型就没事

  5. 可变数据类型:列表(list),字典(dict),集合(set)
    不可变数据类型:字符串(str),整型(int),布尔值(bool),元祖(tuple)
    有序数据类型:字符串(str),列表(list),元祖(tuple)
    无序的数据类型:字典(dict),集合(set)
    可以用索引取值:列表(list),元祖(tuple),字符串(str)
    可以用键取值:字典(dict)
    直接取值:整型(int),布尔值(bool),集合(set)
    
    
  6. 数据类型转换:

    1. 字符串转整型:int(str)
    2. 整型转字符串:str(int)
    3. 字符串转布尔值:bool(str)
    4. 布尔值转字符串:str(bool)
    5. 整型转布尔值:bool(int)
    6. 布尔值转为整型:int(bool)
    7. 列表转元祖:tuple(list)        print(tuple(list))
    8. 元祖转列表:list(tuple)        print(list(tuple))
    9. 列表转集合:set(list)
    print (set(list))
    10. 集合转列表:list(set)
    print(list(set))
    11. 元祖转集合:set(tuple)
    12. 列表转字符串:使用join,
    如下所示:
    list -- str
    lst = ["1","2","3"]             print("".join(lst))
    13.字符串转列表:使用分割
    str -- list
    s = "alex wusir 太白"             print(s.split())
    
    
  7. 重点: 列表乘法,
       	find用法
           join用法
           元祖形式:(1,)--有逗号的才是元祖       		元祖乘法       
           字符串转列表
           列表转字符串
    
    

以后遇到的坑

  1. 死循环:

    lst = [1,2,3]
    for i in lst:
    lst.append(4)
    print(lst)
    
    
  2. 使用for循环清空列表元素内容

    1. 从前向后删除

    2. 创建一个新的容器,循环新的容器删除旧的容器内容

    3. lst = [1,[2]]
      lst[1] =lst
      print(lst)
      答案:[1,[...]]
      
      
    4. 字典和集合:

      1. dic = {"key":1,"key1":2}
        for i in dic:
            if i == "key1":
                dic[i] = dic[i] + 8  
                dic[i] = 10
                else:
                    print("没有这个键!")
        print(dic)
        
        
      2. 字典和集合在遍历(循环)时不能修改原来的大小(字典的长度),可以进行修改值

        s = {1,2,3,4,5,6}
        for i in s:
        	s.pop()
        print(s)
        
        

二次编码

  1. 编码:

    1. ascii码:
      1. 支持英文,数字,符号 1字节
      2. 不支持中文
    2. gbk(国标)
      1. 支持英文,数字,符号 1字节
      2. 支持中文 2字节
    3. unicode(万国码):
      1. 支持英文,数字,符号 4字节
      2. 支持欧洲 4字节
      3. 支持亚洲 4字节
    4. utf-8:
      1. 支持英文,数字,符号 --1字节
      2. 支持欧洲 --- 2字节
      3. 支持亚洲 ---- 3字节
  2. 字节:存储和传输

    1. 编码
    今天是个好日子
    s = "今天"   # b'\xe4\xbb\x8a\xe5\xa4\xa9'
    s1 = s.encode("utf-8") # 编码
    print(s1)
    
    
    1. 解码

      print(b"meet")  #只有字母才能这么搞
      s2 = s1.decode("utf-8") #解码
      print(s2)
      
      
  3. # 必会    #
    python3: 默认编码unicode    
    pyhton2:默认编码ascii    
    python2不支持中文	# 重要:    
    encode()  # 编码    # decode()  # 解码    
    用什么编码就要用什么解码    # 网络传输一定是字节
    
    
posted @ 2019-08-14 19:46  丶Howie  阅读(134)  评论(0编辑  收藏  举报