Python的基础认知

1. 计算机基础知识

• cpu : 人类的大脑,思考 运算和处理问题

• 内存 : 临时储存数据 断电即消失 存储速度快 4G 8G 16G 32G

• 硬盘 : 永久存储数据 存储图片,视频,音频 相对于内存存储慢 500G 1T 2T

• 操作系统 : 其实是一个软件,去控制每个硬件之间的数据交互

2. Python的应用和历史

1. python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，吉多·范罗苏姆（中文名字：龟叔）为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。（龟叔：2005年加入谷歌至2012年，2013年加入Dropbox直到现在，依然掌握着Python发展的核心方向，被称为仁慈的独裁者）。

2. 目前Python主要应用领域：

   • 云计算: 云计算最火的语言， 典型应用OpenStack

   • WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣。。。， 典型WEB框架有Django

   • 科学运算、人工智能: 典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas

   • 系统运维: 运维人员必备语言

   • 爬虫:通过代码来模拟人类访问网页,选择有用信息进行下载

   • 金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，而且重要性逐年提高。原因：作为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定，科学计算和统计分析都很牛逼，生产效率远远高于c,c++,java,尤其擅长策略回测

   • 图形GUI: PyQT, WxPython,TkInter

   • 游戏

3. Python在一些公司的应用：

   • 谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、Google广告等项目都在大量使用Python开发

   • CIA: 美国中情局网站就是用Python开发的

   • NASA: 美国航天局(NASA)大量使用Python进行数据分析和运算

   • YouTube:世界上最大的视频网站YouTube就是用Python开发的

   • Dropbox:美国最大的在线云存储网站，全部用Python实现，每天网站处理10亿个文件的上传和下载

   • Instagram:美国最大的图片分享社交网站，每天超过3千万张照片被分享，全部用python开发

   • Facebook:大量的基础库均通过Python实现的

   • Redhat: 世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的

   • 豆瓣: 公司几乎所有的业务均是通过Python开发的

   • 知乎: 国内最大的问答社区，通过Python开发(国外Quora)

   • 春雨医生：国内知名的在线医疗网站是用Python开发的

   • 除上面之外，还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝 、土豆、新浪、果壳等公司都在使用Python完成各种各样的任务。

4. Python 版本 :

   • Python 2.+ ： C , Java ，C# 源码不统一，功能重复 维护难度大

   • Python 3.+ ：代码统一，代码（功能）重复 维护难度降低

3. Python是一门什么语言

1. 编译型 ： 从头到尾只编译一次

   • 优点 ：运行速度快

   • 缺点 ： 开发速度慢

   • 代表语言 ： C C++ Go

2. 解释型 ：一句一句编译 逐行编译

   • 优点 ： 开发效率高

   • 缺点 ： 运行速度慢

   • 代表语言 ： Python Ruby PHP

4. Python的优缺点

1. 优点 ：

   • Python的定位是“优雅”、“明确”、“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。

   • 开发效率非常高，Python有非常强大的第三方库，基本上你想通过计算机实现任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上再进行开发，大大降低开发周期，避免重复造轮子。

   • 高级语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节

   • 可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工 作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就几乎可以在市场上所有的系统平台上运行

   • 可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。

   • 可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。

2. 缺点 ：

   • 速度慢，Python 的运行速度相比C语言确实慢很多，跟JAVA相比也要慢一些，因此这也是很多所谓的大牛不屑于使用Python的主要原因，但其实这里所指的运行速度慢在大多数情况下用户是无法直接感知到的，必须借助测试工具才能体现出来，比如你用C运一个程序花了0.01s,用Python是0.1s,这样C语言直接比Python快了10倍,算是非常夸张了，但是你是无法直接通过肉眼感知的，因为一个正常人所能感知的时间最小单位是0.15-0.4s左右，哈哈。其实在大多数情况下Python已经完全可以满足你对程序速度的要求，除非你要写对速度要求极高的搜索引擎等，这种情况下，当然还是建议你用C去实现的。

   • 代码不能加密，因为PYTHON是解释性语言，它的源码都是以名文形式存放的，不过我不认为这算是一个缺点，如果你的项目要求源代码必须是加密的，那你一开始就不应该用Python来去实现。

   • 线程不能利用多CPU问题，这是Python被人诟病最多的一个缺点，GIL即全局解释器锁（Global Interpreter Lock），是计算机程序设计语言解释器用于同步线程的工具，使得任何时刻仅有一个线程在执行，Python的线程是操作系统的原生线程。在Linux上为pthread，在Windows上为Win thread，完全由操作系统调度线程的执行。一个python解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行。关于这个问题的折衷解决方法，我们在以后线程和进程章节里再进行详细探讨。

   当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。

   由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写Python解释器来执行Python代码（当然难度很大）。事实上，确实存在多种Python解释器。

5. Python的种类

1. Cpyhon : CPython。这个解释器是用C语言开发的，所以叫CPython。

2. Jython : Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

3. IronPyhon IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

4. PyPy : PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。

Python基础知识

1. Python的安装和环境配置

2. 第一个Python程序

print() 打印 打印到屏幕 print("hello world")

3. 变量

定义变量的规则 :

1. 字母,数字,下划线组成

2. 不能数字开头

3. 不能用python中的关键字

4. 不建议使用中文或拼音

5. 命名要有意义

6. 区分大小写

7. 推荐写法

   驼峰体 : (首字母大写) : ZhangYiDong

   下划线 :( 官方推荐 ) : zhang_yi_dong

4.常量

为了迎合其他的编程语言,,Python语言中, 变量名中全部大写定为常量

5. 注释

作用 : 给一些繁琐的代码加一些描述,加强代码的可读性

两种注释方法 : >>>注释后的代码不能运行

单行注释 : # 只能注释一行,不能换行注释

多行注释 : ''' ''' 支持多行注释

6. 基础数据类型初识

1. 整型 : 数字 关键字 int

2. 字符串 :汉字,字母等 关键字 str Python中只要用引号引起来的就是字符串 字符串可以用"+"拼接

   • 字符串 + 都是字符串的时候才能相加

   • 字符串* 字符串只能和数字相乘

3. 布尔值 : (首字母大写)

   • True : 真 1

   • False : 假 0

4. 列表 list[]

5. 元组 tuple()

6. 字典 dict{"key":"value"}

7. 集合 set{}

8. 用户输入input

   • input ("提示信息") 用户输入内容全部是字符串

   • 用户输入密码不可见 :
     import getpass
     user = input ("请输入用户名:")
     pwd = getpass.getpass("请输入密码:")
     print(user,pwd)

9. 流程控制语句 if

   • if   条件:    #条件判断 > < ==  
         print()   #条件成立后执行的事情
     else :
         执行的活动事件    上条条件不成立后要执行的事件

   • if elif  elif elif   按顺序执行,只要成立,就结束不再往下运行

   • if  if  if  if 只要if成立就执行   一直成立一直执行

   • if 的嵌套 ...............

7. 字符串的格式化输出

# %s -- 占字符串的位置
# %d -- 占整型的位置
# %% -- 转义（把占位转换成普通的%号)

msg = '''
------------------- info ----------------------
姓名: %s
年龄:  %s
性别 : %s
职业:  %s
爱好: %s
------------------- end ------------------------
'''
name = input("请输入你的名字:")
age = input("请输入你的年龄:")
sex = input("请输入你的性别:")
job = input("请输入你的工作:")
hobby = input("请输入你的爱好:")
print(msg%(name,age,sex,job,hobby))

f"{}变量名" 在Python3.6版本中才能实现
msg = f'''
------------------- info ----------------------
name: {input("请输入您的名字:")}
age:  {input("请输入您的年龄:")}
sex : {input("请输入您的性别:")}
job:  {input("请输入您的职业:")}
hobby: {input("请输入您的爱好:")}
------------------- end ------------------------
'''
print(msg)

8. while循环

• while True:   # while 是关键字  条件

• while true :
          print("内容")
          break  #  终止当前循环
          continue # 跳出本次循环,继续执行下一次循环 (理解为伪装成循环体代码最后一行,
                      不再执行下一行的print,直接跳转到开头再次循环)
          print("内容")

• while 条件 :
      print("n内容")
  else :
      print("内容")

9. 运算符

• # 赋值运算
      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

• # 算数运算 :
  +-*/  # 加减乘除
  **   #幂
  //   #取整除    #   例: 9//4 输出结果为4
  % #取余数 (模)

• # 逻辑运算 :
  # amd(与) :
      #1 and 2         >> and两边都是真结果真 , 有一个假结果为假
      #1 and 2         >> and两边都是假的时候 , 结果取 and 后面的内容
      #0 and False  >> and 两边都是假的时候,结果取 and 前面的内容
  # or(或) :
      #1 or 0         >> or  只要有一个是真的,结果就是真    全假结果才为假
      #1 or 4           >> or 两边都是真的时候,结果取 or 前面的内容  (和and相反)
      #False  or 0   >> or 两边都是假的时候,结果取 or 后面的内容 (和and相反)
  # not(非) :
  #计算优先顺序 :
      ()  >   not   >   and   >   or  

• # 成员运算 :
  # in在      not in 不在
  s = "123456"
  if "123"  in s :
      print("内容")
      
  s = "123456"
  print("456" not in s )  

• # 比较运算 :
  #   ==  等于
  #   !=  不等于
  #   >  大于
  #   <  小于
  #   >=  大于等于
  #   <=  小于等于

• # 身份运算 :
  # is  是            
  # is not  不是 
  # is  判断是不是同一个东西    (从源头判断)
  # ==   判断表面上是不是同一个东西

10. 初识编码

• ASCII 英文1个字节 只支持英文

• GBK -- 国标

  • 英文1个字节

  • 中文2个字节

• Unicode 万国码

  • 英文两个字节

  • 中文四个字节

• UTF-8 目前最流行的编码

  • 英文1个字节

  • 欧洲2个字节

  • 亚洲3个字节

• UTF-16

  • 最少用2个字节

• 单位转换

  • 8bit=1byte
    1024byte=1KB
    1024KB=1MB
    1024MB=1GB
    1024GB=1TB
    1024TB=1PB
    1024TB=1EB
    1024EB=1ZB
    1024ZB=1YB
    1024YB=1NB
    1024NB=1DB

11. 整数 int

进制转换

• num = 8
  # num.bit_length()  #  十进制转换二进制的占位位数
  print(num.bit_length())
  #结果是 3  

12. 布尔值

True - 真 False - 假 用于条件判断

• print(bool(-10))     >>> 结果:True    # 0 是 False             非0即True
  print(bool(""))      >>> 结果 :False    # 空的字符串是 False    非空即True
  print(type(str(True)))   结果 : True    布尔值可以转换成字符串
  print(int(False))     >>> 结果 : 0      # True 转化成数字 1   False 转换成数字 0

13. 字符串

字符串 : 用于存储数据 >>>>> Python中只要用引号引起来的就是字符串

1.索引 (下标) [ ] # 从0计数

• name = "alex"    # 从左向右
  name1 = name[2]
  print(name1)
  # 结果 : e

• name = "alex"    # 从右向左
  name1 = name[-2]
  print(name1)
  # 结果 : x

2.切片

• word = "中华人民共和国万岁!"   # 顾头不顾尾
  word1 = word[2:4]
  print(word1)
  # 结果 : 人民

• word = "中华人民共和国万岁!"   
  word1 = word[0:3:2]     # [起始位置:终止位置:步长]
  print(word1)
  # 结果 : 中人

• # print(name[0:100])  # 切片如果终止位置超出了不报错
  # print(name[100])    # 索引取值的时候超出了索引的范围会报错
  # print(name[::])
  # print(name[::-1])  #从左向右           +1 从右向左

• # 总结：
  #     字符串，列表，元组   都是有索引（下标）
  #     索引是准确的定位某个元素
  #     从左向右 0,1,2,3
  #     从右向左 -1，-2，-3，-4
  #     支持索引的都支持切片   [索引]
  #     切片长度可以超出范围，索引长度不能超出范围  [起始位置：终止位置]
  #     步长： 决定要走的方向，决定走的步子多大  [起始位置：终止位置：步长]
  #     # 起始位置 + 步长

3.字符串常用的方法

字符串类型.调用 才叫字符串的方法 例: s.upper() >>>字符串不可变

• #转换英文大小写 :    转换为大写: .upper()    小写 : .lower()
  word = "china"
  word1 = word.upper()
  print(word1)
  # 结果 : CHINA

• #判断字符串以什么开头 :    .startswith()   .endswith()
  word = "你好世界!"
  print(word.startswith("你")
  # 结果 : True             #  判断结尾 : .endswith("内容")

• # 统计  .count()
  word = " asdf123fdefawdf"
  print(word.count("d"))   # 查询 某个内容出现的次数
  # 结果 : 3

• # 替换   .replace()
  word = "Chinb"
  word1 = word.replace("b","a")   
  print(word1)
  # 结果 : China 
  ---------------------------------------------------------------------------
  word = "Chinbbb"
  word1 = word.replace("b","a",2)     #.replace("旧","新",从左往右替换次数)
  print(word1)
  # 结果 : Chinaab 

• #除去首位两边空格   .strip()   >>>脱
  word = "  中国  "
  word1 =word.strip()
  print(word1)
  # 结果 :中国
  ---------------------------------------------------------------------------
  word = "中国  "
  word1 =word.strip("中")   # 在头部没有空格的前提下可以写要去掉的内容
  print(word1)
  # 结果 :国  # 国后面的空格保留不会删掉

• # 分割   .split()  用内容去分割内容 分割后返回的是一个列表
  element = "你好,中国"
  element1= element.split("中")
  print(element1)
  # 结果 : ['你好,', '国']

• #第三种字符串格式化   .format()
  words = "今天天气{},风力{}级!"
  words1 = words.format("晴","四")
  print(words1)
  # 结果 :今天天气晴,风力四级!

• is 系列 -- 判断
  ---------------------------------------------------------------------------
  a = "②"
  print(a.isdigit()) # 判断是不是数字  >>> 小bug  ②在这里是数字
  ---------------------------------------------------------------------------
  a = "666"
  print(a.isdecimal())  # 判断是不是十进制.进而来判断是不是数字    *************
  ---------------------------------------------------------------------------
  a = "China,你好!"
  print(a.isalpha())   # 判断是不是中文 字母  注意标点符号    ***************
  ---------------------------------------------------------------------------
  a = "China,你好!"
  print(a.isalnum())   # 判断是不是字母,中文和阿拉伯数字 ,注意标点符号 *********
  ---------------------------------------------------------------------------
  a = "A"
  print(a.isupper())   # 判断是不是大写

• # 字符串的方法汇总总结
  #1. .upper() 转换大写
  #2. .lower() 转换小写
  #3. .startswith("内容") 判断字符串以什么开头 → 返回的是判断 Ture or False
  #4. .endswith("内容") 判断字符串以什么结尾 → 返回的是判断 Ture or False
  #5. .count("内容") 统计某个元素出现的次数 → 返回的是数字
  #6. .replace("old","new",替换次数) 替换内容 替换次数不填默认全部替换
  #7. .strip()  除去首位两边空格 → 脱
      word = "中国  "
      word1 =word.strip("中")   # 在头部没有空格的前提下可以写要去掉的内容
      print(word1)
      #结果 :国  # 国后面的空格保留不会删掉
  #8. .split() 用内容去分割内容 分割后返回的是一个列表
  #9. .capitalize() 每个字符串首字母大写
  #10. title() 每个单词首字母大写
  #11. swapcase() 大小写转换(大写转为小写,小写转为大写)
  #12. find("内容") 找到返回的是索引 ,找不到返回-1
  #13. index("内容") 找不到会报错

• is 系列 -- 判断
  ---------------------------------------------------------------------------
  a = "②"
  print(a.isdigit()) # 判断是不是数字  >>> 小bug  ②在这里是数字
  ---------------------------------------------------------------------------
  a = "666"
  print(a.isdecimal())  # 判断是不是十进制.进而来判断是不是数字    *************
  ---------------------------------------------------------------------------
  a = "China,你好!"
  print(a.isalpha())   # 判断是不是中文 字母  注意标点符号    ***************
  ---------------------------------------------------------------------------
  a = "China,你好!"
  print(a.isalnum())   # 判断是不是字母,中文和阿拉伯数字 ,注意标点符号 *********
  ---------------------------------------------------------------------------
  a = "A"
  print(a.isupper())   # 判断是不是大写

14. for循环

• len() #  工厂函数  -- 除了int,bool ,其他的类型都可以用
  a = "中国,China,世界"
  print(len(a))   #  计算有多少字符,包括标点符号

• for 循环  只执行一次循环  
  s = "123一二三"
  for a in s :       #中的s是指可迭代对象
      print(a)
  结果:
      1
      2
      3
      一
      二
      三
  -----------------------------------------------------------------------------------
  s = "123"
  for a in s :     
      #print(a)  # 从前到后依次打印
      pass    
      #... # 这是三个英文的点   pass和... 都是占位符  过
  print(a)
  #结果 :3  #分析 for循环体里有pass,最后从s中取出的是3,那么,a的值就是3

15. rang范围

• s = range(1,10)  ******* 面试大坑题  range(1,10) 取不到10
  print(s)
  Python3.x 结果 :range(1, 10)  本身
  Python2.x 结果: [1, 2, 3, 4, 5, 6, 7, 8, 9]

• for i in range(1,10,2): # (起始位置，终止位置,步长)
  ​
  # range(10) 指定了终止位置，起始位置默认是0
  -----------------------------------------------------------------------------------
  for i in range(10,1,-1) : #倒着打印 10,9,8,7,...2  取不到1
      print(i)
  -----------------------------------------------------------------------------------
  for i in range(1) :
      print(i)
  #结果 : 0
  若rang(0),结果为空

16. list列表

认识list列表

• 初识 li = ["地方",12,"abc"] 里面有多个元素 , 每个元素后面用逗号隔开 容器 存放任意类型

  • 两种定义格式 :

    • li = [1,"中国","abc"]

    • li = list("abc")

  • li = list("abc")  底层使用for循环  "abc"可迭代的字符串类型
    prin(li)
    结果 : ["a","b","c"]

  • 列表可以嵌 :

    lst = [1,2,["中国","世界],"你好"]

列表的作用

• 储存大量数据

• 有序 - 支持索引,切片,步长

• 可变 - 可在本身修改

列表的增删改查

增

li = [1,2,3,4,5,6]

• li.append("内容")  # 追加 添加在末尾   
  li.insert(索引,"内容")  # 插入 索引+"内容  >>>效率低
  li.extend("内容") # 扩展 迭代添加
  li.count("内容") # 统计次数
  li.inex("内容") # 返回的是索引  找不到会报错  列表中没有find
  li.reverse() #翻转列表
  li.sort() #排序 默认升序
  li.sort(reverse=True) #降序排序
    列表合并 :
             l1=[1,2.3]     l2=["a","b","c"]
             l3 = l1 + l2
             print(l3)
             #结果 : [1,2.3,"a","b","c"]

删

• li.pop(索引)        # 默认删除的是最后一个     pop有返回值  可以打印 
  li.remove("内容")   # 只能删除第一个
  del li             # 删除容器
  del li[索引]       # 支持索引
  del li[0:3]        # 支持切片
  del li[1:3:2]      # 支持步长
  li.clear()         # 清空  删除容器内的所有内容
  # del  内存回收机制

改

• li[索引]="内容"        
  li[1:2]=[]    # [7,8,9]  #迭代进去,可多可少

• 面试题 :

  li = [1,2,3,4,"abc",5]
  li[0:2] = "ABC" #迭代添加
  print(li)
  #结果:['A', 'B', 'C', 3, 4, 'abc', 5]

  a = 2  b = 1
  a,b = b,a
  print(a,b)

• 步长 ,取几个,就放回几个,不能多也不能少

  li = ["水杯",2,3,"abc",]
  li[0:3:2] = [1,2,3],[1234]
  print(li)

查

• li = [1,2,3,4,5,6]
  print(li[0])#索引查
  #结果 : 1
  print(li[1:3])
  #结果 :[2,3]

17. 元组

认识元组

元组和列表一样可以存放任意类型数据

• 元组关键字 tuple   
  书写格式  tu = ("哈哈",1)      #逗号隔开
  tu = ("哈哈")     # 小括号中只有元素,没有逗号,结果为元素本身
  print(tu)  结果 :哈哈
   ---------------------------------------------------------------------------------
  tu = (1,)    # 小括号中有一个元素后有逗号的就是元组
  tu = ()     # 空的小括号也是元组   print 结果是 : 0

• 元组是有序的:

  • 有索引,切片,步长

  • 元组不可变 (列表可变),不可变意味着不能增删改

    • 存一些不想让别人修改的数据,一般用于在配置文件中,防止误操作.

• # 索引
      # print(tu[1])
      # 切片
      # print(type(tu[1:1000]))  # 切片返回的是切之前的数据类型
      # 步长
      # print(tu[::2])

• 元组可嵌套

18. dict字典

认识dict字典

• 字典 关键字 : dict 其他语言的字典叫键值对数据

  格式 : {"键":"值"} {"key":"value"}

  • 键 ： 必须是可哈希的（不可变的数据类型），并且是唯一的

  • 值 ：任意

• 字典是无序的 字典可以增删改查

字典的用处

• 储存大量数据，字典比列表还要大

• 字典查找值方便，快速

• 字典能够把数据进行关联

• 字典比较耗内存，最长使用的数据 ： 字符串，列表 ，字典

• 有明确的对应关系时，推荐使用字典

字典的增删改查

增

• dic = {"a":"b","b":"c"}
  dic.setdefault("c","aaa")
  print(dic)
  # 结果 {'a': 'b', 'b': 'c', 'c': 'aaa'}
  ​
  dic.setdefault("a","aaa")
  print(dic)
  # 结果 {'a': 'b', 'b': 'c'}
  ​
  setdefault :
  # 先查看字典中是否有要添加的键值，有就不修改，没有就添加进去

• dic["s"] = "ssss"   # dic[键] = 值
  print(dic)
  # 结果 ： {'a': 'b', 'b': 'c', 's': 'ssss'}
  # 同样这个方法也可以修改

• # 定义字典方式 : 
  dic = {"k1":"v1","k2":"v2"}  or dic = dict(k1="v1",k2="v2")
  1. dic.popitem()  #随机删除  在pytnon 3.6版本以上默认删除最后一个键值对,3.6以下随机删除
  2. 批量创建字典  dic = dict.fromkeys(可迭代对象,每一个key的值)
     dic1 = dict.fromkeys("abcdef",1)

删

• dic = {"a":"b","b":"c"}
  print(dic.pop("a"))   #通过键删除  pop具有返回值,返回的是被删除的值
  print(dic)
  结果 ：{'b': 'c'}
  字典中没有remove方法

• del dic # 删除整个字典
  del dic["b"] # 删除指定的键值对
  dic.clear # 清空

改

• dic = {"a":"b","C":"c"}
  dic["b"] = "这是值"   # 键在字典中存在就是修改,键在字典中不存在就是增加
  print(dic)
  结果 ： {'a': 'b', 'C': 'c', 'b': '这是值'}

• dic2 = {1:2,"a":"a1"}
  dic2.update(dic)   # update括号里的字典级别高
  print(dic2)
  结果 ： {1: 2, 'a': 'b', 'C': 'c'}

查

• # 字典的查询只能通过键获取值,不能通过值获取键
  dic = {1:2,"a":"a1"}
  print(dic["c"])  # 如果有键在字典中存在就放回键对应的值,如果不存在就报错
  get  -- 获取
  print(dic.get("c","这是返回值")) #
  # 获取值的时候可以指定返回的内容,键不存的时候返回None不报错

• # dic = {1:2,"a":"a1"}
  # for i in dic:   # for循环字典的时候打印的是字典的键
  #     print(i,dic[i])

一些操作举例

• dic = {"1":1,"2":2,"3":3,"4":4}
  # # 删除"2"  2种方式
  dic.pop("2")
  del dic["2"]
  ​
  # # 添加 "5":5 2种方式
  dic.setdefault("5",5)
  dic["5"] = 5
  ​
  # # 修改: "1":10086
  dic["1"] = 10086
  ​
  # # 查看"3"的值
  dic.get("3",'没有值')
  # dic["3"]  # 没有就会报错

• dic = {"1":1,"2":2,"3":3,"4":4}
  li = []
  for key in dic:
      li.append(key)
  print(li)
  # 结果 : ['1', '2', '3', '4']

• #高仿列表
  dic = {"1":9,"2":2,"3":3,"4":4}
  for i in dic.keys():#高仿列表
      print(i)  # 打印的是键
  # 结果 : 
      1
      2
      3
      4

• 其他操作:
  获取所有的键 :   keys()   --- 高仿列表  没有索引
  获取所有的值 :   values()  --- 高仿列表  没有索引
  获取所有的键值 : items()   --- 以元组的形式存放  键是元组中的第一个元素, 值是第二个元素

• dic = {"1":1,"2":2,"3":3,"4":4}
  print(type(dic.keys()))   # 可以for循环,但是不能索引
  dic_li = dic.keys()
  print(dic_li)  
  #结果 :
   <class 'dict_keys'>
  dict_keys(['1', '2', '3', '4']

• dic = {"1":1,"2":2,"3":3,"4":4}
  print(dic.values())   # 打印的是键值
  # 结果 : dict_values([1, 2, 3, 4])

• dic = {"1":1,"2":2,"3":3,"4":4}
  for i in dic.items():
       print(i)
  #结果 :
  ('1', 1)
  ('2', 2)
  ('3', 3)
  ('4', 4)

• # 解构
  # a = 1
  # b = 2
  # print("is a",id(a))
  # print("is b",id(b))
  # a,b = b,a
  # print("is a",id(a))
  # print("is b",id(b))

• dic = {"1":1,"2":2,"3":3,"4":4}
  for key,value in dic.items():
      print(key,value)
  # 结果 : 
      1 1
      2 2
      3 3
      4 4
  ​
  # keys,values,items,解构
  dic = {"1":1,"2":2,"3":3,"4":4}
  for i in dic:        # 效率高
      print(i,dic[i])
  # 结果同上   
  ​
  for k,v in dic.items():
      print(k,v)
  # 结果同上    

• 购物车

  dic = {"电脑":15000,"手机":8000,"耳机":4000,"老婆":1111}
  count = 1
  for i in dic:
      print(count,i)
      count += 1
  # 结果 :
      1 电脑
      2 手机
      3 耳机
      4 老婆   

• 枚举

  li = [1,2,3,4,54]
  for i,k in enumerate(li,0):  # enumerate 第二个参数默认不写就是0    -- 枚举
      print(i,k)  #第二个参数是指从数字几开始计数
  # 结果 :        #打印的时候,第二个参数是第一个(先打第二个参数)
      0 1
      1 2
      2 3
      3 4
      4 54   

字典的嵌套

# dic = {
#     101:{1:["周杰伦","林俊杰"],2:{"汪峰":["国际章",{"前妻1":["熊大","熊二"]},
#                                   {"前妻2":["葫芦娃","木吒"]}]}},
#     102:{1:["李小龙","吴京","李连杰"],2:{"谢霆锋":["张柏芝","王菲"]},
#          3:["alex","wusir","大象","奇奇"]},
#     103:{1:["郭美美","干爹"],2:{"王宝强":{"马蓉":"宋哲"}}},
#     201:{1:["凹凸曼","皮卡丘"],2:{"朱怼怼":{"杨幂":"刘恺威"}}}
# }
​
# print(dic[101][2]["汪峰"][2]["前妻2"][0])
#['国际章', {'前妻1': ['熊大', '熊二']}, {'前妻2': ['葫芦娃', '木吒']}]
#{'前妻2': ['葫芦娃', '木吒']}
#['葫芦娃', '木吒']
​
# home1 = dic[102][3][2]
# {1: ['李小龙', '吴京', '李连杰'],
# 2: {'谢霆锋': ['张柏芝', '王菲']},
# 3: ['alex', 'wusir', '大象', '奇奇']}
# print(home1)
​
# print(dic[103][2]["王宝强"]["马蓉"])

19. set集合 -天然去重

认识集合

• set {1,2,3} s = {1,2,3,"123",false,(1,2,3,4)}

• 集合就是一个没有值的字典,遵循唯一,无序, 元素要求可希哈(不可变)

  • 集合是无序的,

  • 集合是可变的

集合的增删改

增

• s.update("3456")    #迭代添加
  s.add(添加的内容)

删

• s.pop()   #随机删除
  s.remove(删除的内容)
  s.clear()   #清空
  del s

改

• 删了再添加

去重

• li = [1,2,3,4,2,1,3] #一行代码去重
  print(list(set(li)))

其他操作

• #   差集   ( - 或者 difference )    
  set1 = {1,2,3,4,5}
  set2 = {4,5,6,7,8}
  print(set1 - set2)   # 结果: {1, 2, 3}
  print(set1.difference(set2))  # 结果: {1, 2, 3}

• #   并集   ( | 或者 union)
  set1 = {1,2,3,4,5}
  set2 = {4,5,6,7,8}
  print(set1 | set2)  # 结果:{1, 2, 3, 4, 5, 6, 7,8}
  print(set2.union(set1))  # 结果:{1, 2, 3, 4, 5, 6, 7,8}

• # 交集  ( & 或者 intersection )
  set1 = {1,2,3,4,5}
  set2 = {4,5,6,7,8}
  print(set1 & set2)  # 结果 : {4, 5}
  print(set1.intersection(set2))  # 结果 : {4, 5}

• #   对称差集  - 反交集   ( ^ 或者symmetric_difference)
  set1 = {1,2,3,4,5}
  set2 = {4,5,6,7,8}
  print(set1 ^ set2)  # 结果:  {1, 2, 3, 6, 7, 8}
  print(set1.symmetric_difference(set2))  # 结果: {1, 2, 3, 6, 7, 8}

• #   超集和子集
  set1 = {1,2,3}
  set2 = {1,2,3,4,5,6}
  ​
  print(set1 < set2) # True
  print(set1.issubset(set2))  # True 这两个相同，都是说明set1是set2子集。
  ​
  print(set2 > set1) # True
  print(set2.issuperset(set1))  # True 这两个相同，都是说明set2是set1超集。

• #   冻结集合 (可变转换成不可变)  -- 不常用
  f_s = frozenset({1,2,3,4,5})
  dic = {f_s:"1"}
  print(dic)

20. 深浅拷贝

深浅拷贝用在不让修改原数据的数据的时候使用

浅拷贝

• 对于浅copy来说,第一层创建的是新的内存地址,而从第二层开始指向的都是同一个内存地址,所以,对于第二层以及更深层的层数来说,保持一致性.

• # l1 = [1,2,3,4,[4,5,6]]
  # l2 = l1[:]   # 浅拷贝
  # l2 = l1.copy() # 浅拷贝  -- 只拷贝第一层
  ​
  l1 = [1,2,3,['hello','world']]
  ​
  l2 = l1.copy()
  print(l1,id(l1))  # [1, 2, 3, ['hello', 'world']] 1920725366664
  print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 1920726234696
  l1[1] = 222
  print(l1,id(l1))  #[1, 222, 3, ['hello', 'world']] 1920725366664
  print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 1920726234696
  ​
  l1[3][0] = 'everybody'
  print(l1,id(l1[3]))  # [1, 222, 3, ['everybody', 'world']] 1920726234824
  print(l2,id(l2[3]))  # [1, 2, 3, ['everybody', 'world']] 1920726234824

深拷贝deepcopy

• 对于深copy来说,两个是完全独立的,改变任意一个任何元素(无论多少层),另一个也绝不会改变

• import copy
  ​
  l1 = [1,2,3,['hello','world']]
  l2=copy.deepcopy(l1)
  print(l1,id(l1))  # [1, 2, 3, ['hello', 'world']] 2200548595592
  print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 2200548596424
  l1[1] = 222
  print(l1,id(l1))  #[1, 222, 3, ['hello', 'world']] 2200548595592
  print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 2200548596424
  ​
  l1[3][0] = 'everybody'
  print(l1,id(l1[3]))  # [1, 222, 3, ['everybody', 'world']] 2200548595400
  print(l2,id(l2[3]))  # [1, 2, 3, ['hello', 'world']] 2200548596360

21. 小数据池

• 小数据池是Python中的一种提高效率的方式,固定数据类型,,使用同一个内存地址

• 小数据池支持的数据类型 : str , int , bool

• # == 比较的是值
  # is 比较的是内存地址

• 1. 当我们在控制台(cmd)的时候,代码块与代码块之间的规则:
      A.数字:-5~256之间额整数会被缓存
      B.字符串:
          1.小于等于1会默认缓存
          2.长度大于1,如果字符串中只有数字,字母下划线会缓存
          3.乘法得到的字符串:
              如果乘法得到的最终的字符串不超过20,会缓存
              手动指定缓存 : from sys import intern  intern(指定缓存的内容)
      C.布尔值会被缓存
  2.py文件中,一个代码块内部,只会缓存int,str,bool,py中有自己的小数据池,范围比外面的代码块的数据池要大
      a.数字.都会缓存.运算结果不缓存(-5~256的结果会缓存)
      b.字符串.默认的字符串都会缓存,如果有乘法,遵循1.b.3的规则
      c.布尔值,默认缓存

• # 代码块的规则:
      # 数字: 全部驻留
      # 字符串:
          #1.字符做乘法的时候总长度不能超过20
          #2.自定定义的都驻留
          #3.乘数为1的时候 就是赋值
          #4.python3.7 乘法的时候总长度不能超过4096
  ​
  # 总结:
      # 小数池 -- 支持: str,int,bool
      #小数据池数字: -5 ~ 256
      #小数据池字符串: 乘法时结果长度不能超过20

22. 数据类型转换

• 1. str → int # 字符串转整型 字符串必须都是十进制的数
      int(str)
  2. int → str # 整型转字符串
      str(int)
  3. str → list # 字符串转换成列表
      list(str) #字符串转列表  字符串会迭代
      str.split() # 字符串会成为一个元素,转换成列表,不会迭代
  4. list → str # 列表转换成字符串
      ''.join(list)  # 列表中不能有int整型数字
  5. list → tuple # 列表转换元组
      tuple(list)
  6.tuple → list # 元组转换列表
      list(tuple)
  7. set → list # 集合转换列表
      list(set)
  8. list → set # 列表转换集合
      set(list)
  # 总结1 :
      1. 字符串→数字 :字符串中必须都是十进制的数字
      2. 数字→数字  : 直接转换
      3. 列表→字符串 : ''.join() # 可迭代对象,不能出现数字
      4. 字符串→列表 : .split()
      5. 除字典外,容器数据类型之间可以直接相互转换
  # 总结2 :
   1. 学到的数据类型 :
      str,int,bool,list,tuple,dict,set
   2. 有序的数据类型 :
      str,int,bool,list,tuple
   3. 无序 :
      dict,set
   4. 可变 :
      list,dict,set
   5. 不可变 :
      str,int,bool,tuple
   6.访问方式 :
      直接访问 : int,bool,set
      顺序访问 : str,list,tuple
      通过键访问 : dict

23. 坑

• 针对索引值是奇数的删除

  • li = [1,2,3,4]  # [1,3,4]
    # 索引值是奇数的删除
    for i in range(4):
        if i % 2 == 1:
            li.pop(i)   # 会报错 解释:列表可变,删除元素后,索引值会改变
    print(li)

  • li = [1,2,3,4,5]   #[1,3,4,5]
    # 索引值是奇数的删除
    for i in range(4):
        if i % 2 == 1:
            li.pop(i)   # 结果不对
    print(li)

  • #正确操作
    li = [1,2,3,4,5]
    for i in range(len(li)-1,-1,-1):
        if i % 2 == 1:
            li.pop(i)   # 倒序删除
    print(li)

  • #正确操作
    #偷换感念 >>> 删除索引是奇数的
    li = [1,2,3,4,5]
    new_li = []
    for i in range(len(li)):
        if i % 2 == 1:
            new_li.append(li[i])
    for em in new_li:
        li.remove(em)
    print(li)

  • li = [1,2,3,4,5]
    del li[1::2]
    print(li) # 结果 :[1, 3, 5]

• 使用for删除列表的时候从左向右删除,会报错.结果不对

  • dic = {"k1":"v1","k2":"v2"}
    for i in dic:
        dic["k3"] = "v3"
    print(dic) #结果报错
    #不能在遍历字典本身中改变大小,要批量删除字典的键值对
    dic = {"k1":"v1","k2":"v2","k3":"v3"}
    for i in dic:
        dic["k7"] = "1"
    print(dic) # 结果:报错

  • # 删除字典  不能在遍历字典本身中改变大小,要批量删除字典的键值对
    dic = {"k1":"v1","k2":"v2","k3":"v3"}
    li = []
    for i in dic:
        if i == "k1" or i == "k3":
            li.append(i)
    for em in li:
        dic.pop(em)
    print(dic)

  • li = [1,2,3,4]
    for i in li:
        li.append(i)
    print(li)
    #结果: 程序一直在运行,但是会显示空白,列表是可变的,会一直...

24. 编码解码

• # ascii     不支持中文
                      字  节
  # gbk       国标   英文1 中文2
  # unicode   万国码 英文2 中文4
  # utf-8     英文1  欧洲2 亚洲3

• # python3内存使用的就是unicode
  # python2内存使用的就是ascii

• # 编码
  s = "你好"
  s1 =s.encode("gbk")
  print(s1)
  结果 :b'\xc4\xe3\xba\xc3'
  --------------------------------------------------------------------
  # 解码
  s2 = b'\xc4\xe3\xba\xc3'
  s3 = s2.decode("gbk")
  print(s3)
  结果 : 你好 

25. 文件操作

• 使⽤用python来读写⽂文件是非常简单的操作. 我们使⽤用open()函数来打开⼀一个⽂文件, 获取到⽂文 件句句柄. 然后通过⽂文件句句柄就可以进⾏行行各种各样的操作了了. 根据打开⽅方式的不同能够执⾏行行的操作也会有相应的差异.打开⽂文件的⽅方式: r, w, a, r+, w+, a+, rb, wb, ab, r+b, w+b, a+b 默认使⽤用的是r(只读)模式

• 模式

  • r 读 ,只能读

  • w 写,只能写

  • a 追加写,只能写入

一般书写格式格式

• f = open("文件",mode = "模式",encoding = "编码")    #  这里f是一个可迭代对象 

• f = open("文件",mode = "r",encoding = "编码") 
  content = f.read()  # 读取全部内容 →缺点:读大文件时,内存容易溢出,    
  content = f.read(3) # 从前往后读取三个字符
          f.readline()  #打印一行
          print(content)
          f.close()  # 关闭

• #f是一个可迭代对象
  for line in f : # 内部调用的是readline()
      print(line)  #一行一行打印
   f.close() #关闭  

写

• f = open("文件",mode = "w",encoding = "编码")   #写模式,若没这个路径,则会自动在相应路径下创建文件
  f.write("要写进去的内容")  #写的时候,在本次打开的时候先清空,再写入    
  f.flush() #刷新
  f.close()
  #追加写 : a 
  f = open("文件",mode = "a",encoding = "编码") 

非文本操作b

• b:bytes  这个时候处理的文件是字节
  rb
  wb
  ab
  f = open("文件",mode = "rb") #没有编码

• #网络请求
  import requests
  ret = requests.get("http://www.521609.com/uploads/allimg/151124/1-1511241G251317.png")
  f = open("2.jpg",mode="wb")
  f.write(ret.content)
  f.close()

• #文件拷贝
  f1 = open("路径",mode="rb")
  f2 = open("保存的地址及文件名".mode = "wb")
  for line in f1 :
      f2.write(line)
  f1.close()
  f2.flush()
  f2.close()
  

r+ ,w+ , a+

• r+ 正确用法: 先读后写 # 深坑,在r+的模式下.只要是执行了读,再写就在末尾写**

  • f = open("地址",mode="r+",encoding="utf-8")
    f.wirte("写入的内容")  #如果上来直接写,则写在文件开头,并且覆盖原文
    

  • f = open("地址",mode="r+",encoding="utf-8")
    s = f.read(1)  # 读取一个字符
    print(s)
    f.wirte("写入的内容")  #  如果已经执行了读操作,后面的写都是在文件末尾,和光标没有关系
    

• w+ 写读 正确使用 :先写后读(执行写的时候先清空)

  • f = open("地址",mode="w+",encoding="utf-8")
    f.seek(0) # 光标移动到开头
    

• a+ 追加读写模式

  • f = open("地址",mode="a+",encoding="utf-8")
    

断点续传

• r+b

  w+b

  a+b (常用)

光标

• #tell查找光标  单位字节
  #seek(1) 移动光标 单位字节
  #read(1)  单位字符
  #seek(0,2) 光标移动到末尾    seek(偏移量,位置)    位置 :0开头  1当前位置  2,末尾  默认o
  

truncate() 截断文件

• f = open("地址",mode="r+",encoding="utf-8")
  f.seek(9)
  f.truncate(9)#如果没有参数,按照光标截断,如果有参数,截断到参数位置
  

文件修改

• import os # 引入os模块
  with open("路径",mode="r",encoding="utf-8") as f1,\
      open("路径副本",mode="r",encoding="utf-8") as f2 :
      for line in f1:
          ...
  os.remove("路径")
  os.rename("路径副本","路径")
  

26. 三种格式化输出

1. %s , %d .....

   • print("我的名字叫%s,我的爱好是%s"%("张三","听音乐"))
     结果:我的名字叫张三,我的爱好是听音乐
     

   格式符

   • 格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:
     
     %s    字符串 (采用str()的显示)
     
     %r    字符串 (采用repr()的显示)
     
     %c    单个字符
     
     %b    二进制整数
     
     %d    十进制整数
     
     %i    十进制整数
     
     %o    八进制整数
     
     %x    十六进制整数
     
     %e    指数 (基底写为e)
     
     %E    指数 (基底写为E)
     
     %f    浮点数
     
     %F    浮点数，与上相同
     
     %g    指数(e)或浮点数 (根据显示长度)
     
     %G    指数(E)或浮点数 (根据显示长度)
     

2. f

   f"{}变量名" 在Python3.6斑斑中才能实现
   msg = f'''
   ------------------- info ----------------------
   name: {input("请输入您的名字:")}
   age:  {input("请输入您的年龄:")}
   sex : {input("请输入您的性别:")}
   job:  {input("请输入您的职业:")}
   hobby: {input("请输入您的爱好:")}
   ------------------- end ------------------------
   '''
   print(msg)
   

3.format 的三种格式化输出

形式一 :  >>> 必要要一一对应
print("我的名字是{},我住在{},我的爱好是{}".format("张三","河北","唱歌"))

形式二 :
print("我的名字是{0},我住在{1},我的爱好是{2}".format("张三","河北","唱歌"))

形式三 :
print("我的名字是{name},我住在{site},我的爱好是{hobby}".format(name="张三",hobby="唱歌",site="河北"))

函数和模块

1. 函数 - 面向过程编程

初识函数

• 函数 ：函数是以功能为导向，一个函数封装一个功能，登录，注册，评论，文件操作等

• 优点：减少代码重复，提高代码的可描述性

• #获取任意一个字符串的元素的个数
  s1 = 'fdskjlgfdgfdjkslgdfjkjafdsajk'
  count = 0
  for i in s1:
      count += 1
  print(count)
  
  
  #获取列表的元素的个数
  l1 = [1, 2, 3]
  count = 0
  for i in l1:
      count += 1
  print(count)
  
  # 利用函数
  l1 = [1, 2, 3]
  def new_len():
      count = 0
      for i in l1:
          count += 1
      	print(count)
  new_len()
  

函数的结构

• def func() :

  原文地址：https://www.cnblogs.com/qmuy/p/11368596.html