Python基础笔记

conda --version 检查版本
conda update conda 升级版本
conda info -envis或者(-e) 列出所有环境
activate xx 激活环境
conda remove -n xx 删除环境
https://youtu.be/vgDFnlkM9ig

find(’’)找到 split(’’)拆分 replace(’’,’’)替换 strip(’’)删除 append(’’) 增加

• panda
  pd.Series(data=数据列表,index=索引列表,name=图表名称)
  import pandas as pd
  my_series = pd.Series(data = [‘我’,‘是’,‘梦想’,‘橡皮擦’],index=[‘a’,‘b’,‘c’,‘d’],name=‘梦想序列’)
  my_series1 = pd.Series({‘a’:‘非本科程序员’,‘b’:‘公号’})
  print(my_series,my_series1)

  dict = {
  ‘boys’:[1,2,3],
  ‘girl’:[5,6,7]
  }
  df = pd.DataFrame(dict)
  df = pd.DataFrame([[1,5],[2,6],[3,7]],columns=[‘boys’,‘girls’],index=[‘class1’,‘class2’,‘class3’])
  print(df)

  数据行列

  df.shape

  缺失值

  df.isna().sum()

  弃去缺失值

  df.dropna(inplace=True)

• 三元运算
  #三元运算,就是if条件判断，前后各有一个值,指向一个变量
  #条件成立，就将第一个值赋给变量，条件不成立就将第二个值赋给变量
  #就是一个条件判断，和两个不同的值组合成的判断运算，就是三元运算
  a = 11
  b = “小屁孩”
  c = “小青年”
  #判断如果a变量小于或者等于10就将b变量赋值给nian变量，否则就将c变量赋值给nian变量
  nian = b if a <= 10 else c
  print(nian)

• 冒泡排序（小到大）
  #冒泡排总的流程（重点）
  li = [11, 7687, 34, 99, 34678, 3456, 8759, 546]

  for j in range(1, len(li)): #len检查li列表有多少个元素,将返回数当做参数传入range创建成循环次数从1开始循环
  for i in range(len(li) - j): # len检查li列表有多少个元素，将返回数-1当做参数传入range创建成循环次数
  if li[i] > li[i + 1]: # 每次循环的次数和次数加1当做列表的索引取出列表的两个元素，判断第一个元素是否大于第二个元素
  huh = li[i] # 如果第一个元素大于第二个元素，将第一个元素赋值给一个变量
  li[i] = li[i + 1] # 将第一个元素等于第二个元素
  li[i + 1] = huh # 将第二个元素等于赋值的huh变量，这样第一元素和第二元素就进行互换位置
  print(li)
  #打印出 [11, 34, 99, 546, 3456, 7687, 8759, 34678]

• 程序打包
  pyinstaller -F 文件名.py
  …

• time
  线程推迟指定时间运行
  time.sleep(2)
  时间戳
  time.time()
  结构化时间–当地时间
  time.localtime()
  结构化时间–UTC
  time.gmtime()
  将结构化时间转化成时间戳
  time.mktime(time.localtime())
  将结构化时间转化成字符串时间
  time.strftime("%Y-%m-%d %X",time.localtime())
  将字符串时间转化成结构化时间
  time.strptime(“2018:12:22:22:35:38”,"%Y:%m:%d:%X")

• random
  0-1的浮点数
  random.random()
  随机整型
  random.randint(a,b) 返回a,b之间的整数，包含a,b
  random.randrange(a,b) 返回的数<b
  随机取列表中的数
  random.choice([11,22,33]) 随机取出一个
  random.sample([11,22,33],2) 随机取出两个
  随机范围的浮点型
  random.uniform(1,4)
  把列表中的元素随机排序
  random.shuffle([11,22,33,2])
  测试随机验证码
  for i in range(5):
  num=random.randint(0,9)
  alf=chr(random.randint(65,138))
  s=str(random.choice([num,alf]))
  ret+=s

• sys
  修改环境变量(临时修改)
  sys.path.append()
  退出程序
  sys.exit(0)

• os
  拼接地址
  os.path.join(“D:\mm131”, name)
  判断文件是否存在
  os.path.exists()
  更改当前脚本工作目录
  os.chdir(“test”)
  生成单层目录
  os.mkdir(‘test’)
  获取当前运行脚本的绝对路径
  os.path.dirname(file)
  获取当前运行脚本的绝对路径（去掉最后一个路径）
  os.path.dirname(os.path.dirname(file))
  获取当前工作目录
  os.getcwd()
  生成多层递归目录
  os.makedirs(‘test/test2’)
  删除空目录
  os.rmdir(‘test’)
  递归删除空目录
  os.removedire(‘test1/test2’)
  删除文件
  os.remove()
  列出指定目录下的所有文件
  os.listdir(‘test’)

• json (转换为字符串)
  json.dumps() 转换为json数据
  json.loads() 把json数据解码

• pickle (转换为字节bytes)
  pickle.dumps() 转换为字节
  pickle.loads() 把字节解码

• hashlib加密模式
  import hashlib #引入hashlib模块
  a = hashlib.md5() #hashlib.md5()定义md5加密方式
  a.update(bytes(‘加密内容’, encoding=‘utf-8’)) #bytes()将要加密的内容转换成二进制,update()将二进制追加更新到加密对象里
  print(a.hexdigest()) #hexdigest()获取加密对象里加密后的密串
  #print(a.digest()) #digest()获取加密对象里加密后的密串二进制

  #输出

  220be55b2e3d8e60f9214b04a7a2328f

• format()

  格式化

  template = “awdwadwad{0}.,wada{1}”
  v = template.format(“wd”,18)

• range()

  帮助创建连续的数字，通过步长来指定不连续

  v = range(0,100,5)
  print(v)

  将文字对应的索引打印出来

  test = input(">>>")
  for item in range(0,len(test)):
  print(item,test[item])

• re
  元字符(.):是包含特殊意义的字符，一般都是和普通字符搭配使用的
  元字符(^):字符串开始位置与匹配规则符合就匹配，否则不匹配
  [^{a-z]反取，匹配出除字母外的字符，}元字符如果写到字符集里就是反取
  元字符($):字符串结束位置与匹配规则符合就匹配，否则不匹配
  元字符():匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪（规则里的元字符）前面的一个字符可以是0个或多个原本字符
  元字符(+):匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪（规则里的+元字符）前面的一个字符可以是1个或多个原本字符
  元字符(?):（规则里的?元字符）前面的一个字符可以是0个或1个原本字符
  {}元字符 {m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次
  []元字符 （规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配
  反斜杠后边跟元字符去除特殊功能 .
  反斜杠后边跟普通字符实现特殊功能 \d 相当于类[0-9] \w 匹配包括下划线在内任何字母数字字符，[a-zA-Z0-9_]
  普通匹配
  re.findall(“匹配规则”, “要匹配的字符串”)
  import re
  a = re.findall(“匹配规则”, “这个字符串是否有匹配规则的字符”)
  print(a) #以列表形式返回匹配到的字符串
  #打印出 [‘匹配规则’]
  分组匹配
  #也就是分组匹配，()里面的为一个组也可以理解成一个整体
  a = re.search(r"(a4)(dg)g\2", “a4a4a4a4a4dggdg4g654gb”) #引用序号对应的字组所匹配的字符串,\2就是引用第2个组(dg)
  b = a.group()
  print(b)
  #打印出 a4dggdg
  a = re.search(“a(\d+)”, “a466666664a4a4a4dg4g654gb”) #匹配 (a) (\d0-9的数字) (+可以是1个到多个0-9的数字)
  b = a.group()
  print(b)
  #打印出 a466666664
  匹配模式
  tt = “Tina is a good girl, she is cool, clever, and so on…”
  rr = re.compile(r’\woo\w’)
  a = rr.findall(tt) #查找所有包含’oo’的单词
  print(a)
  #执行结果如下：
  [‘good’, ‘cool’]
  match()函数
  #无分组
  origin = “hello alex bcd alex lge alex acd 19”
  r = re.match(“h\w+”, origin) #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
  print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
  print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
  print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
  #输出结果
  # hello 匹配到的全部拿出来
  # () 没有分组所以为空
  # {} 没分组部分定义了key的组所以为空

    # 有分组
    # 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
    r = re.match("h(\w+)", origin)   #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
    print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
    print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
    print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
    #输出结果
    # hello         匹配到的全部拿出来
    # ('ello',)     有分组，在匹配到的字符串中拿出分组的部分
    # {}            没分组部分定义了key的组所以为空
  

• 列表 有序；元素可以被修改
  中括号[]括起来 ，分割每个元素 列表里可以是数字,字符串,列表,布尔值…
  li = [1,12,32,[“你好”,“hello”],“awd”]
  字符串转换列表 li = “wadawdwadwa” new_li = list(li)
  删除 del li[1]
  修改 li[1] = 120
  追加 li.append(“a”)
  清空列表 li.clear()
  拷贝 v=li.copy()
  计算元素出现次数 li.count(22)
  追加可迭代对象(字符串、列表) li.extend([123,“awd”])
  根据值获取当前值索引位置 li.index(123)
  指定索引位置插入元素 li.insert(0,“wad”)
  删除某个值,并获取删除的值 li.pop(1)
  删除列表中的指定值 li.remove(22)
  将当前列表进行翻转 li.reverse()
  列表排序 li.sort()

• 元组 有序；一级元素不可被修改,不能被增加或删除
  li = (132,“wadwa”,[(21,2)],(12,1),True,)
  通过索引或切片取值 可以for循环(可迭代对象)

• 字典 无序；可变；列表、字典不能作为字典的key,value可以是任意值
  info = {
  1 :“wad”,
  “k”:“wda”,
  True:“123”,
  (11,22):123, }
  获取字典的key和value
  for k,v in info.items():
  print(k,v)
  keys() values() items() get() pop() copy() update()

• 集合 无序；元素序列不重复
  可以使用大括号(不能创建空集合) { } 或者 set()
  add(key) ：添加元素到set中
  remove(k):删除元素

• 变量
  变量名 = 值
  全局变量是在整个py文件中声明，全局范围内都可以访问
  局部变量是在某个函数中声明的，只能在该函数中调用它
  想要在函数体内修改全局变量的值，就要使用global关键字
  修改上一层的变量的值，使用nonlocal关键字

• 函数
  定义一个空函数
  def nop():
  pass
  函数的参数
  def enroll(name, gender, age=6, city=‘Beijing’):
  print(‘name:’, name) #位置参数
  print(‘gender:’, gender) #位置参数
  print(‘age:’, age) #默认参数
  print(‘city:’, city) #默认参数
  递归函数
  在函数内部，可以调用其他函数。函数在内部调用自身本身，它就是递归函数
  def fact(n):
  if n==1:
  return 1
  return n * fact(n - 1)
  匿名函数
  python 使用 lambda 来创建匿名函数 不能访问自己参数列表之外或全局命名空间里的参数
  所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数
  func = lambda x:x+1
  print(func(10))
  函数式编程（高阶函数）
  map函数
  python内置高阶函数，它接收一个函数f和一个list，并把f依次作用在list每个元素上，得到一个新的list并返回
  def f(x):
  return x*x
  print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
  [1, 4, 9, 10, 25, 36, 49, 64, 81]
  filter函数
  接收一个函数f和一个list,这个函数f的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list
  def is_odd(x):
  return x % 2 == 1
  filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
  [1, 7, 9, 17]
  reduce函数
  它接收一个函数f和一个list,传入的函数f必须接收两个参数,对list每个元素反复调用函数f，并返回最终结果值
  def f(x, y):
  return x + y
  reduce(f, [1, 3, 5, 7, 9])
  最终结果：25
  内置函数
  …
  …

• 文件处理
  CSV
  with open(‘xx.csv’,‘a+’,newline=’’) as f:
  write = csv.writer(f)
  write.writerow((pm,bt))
  打开文件的模式
  r,只读模式(文件必须存在)
  w,只写模式(不可读,文件不存在则创建,存在则清空内容)
  x,只写模式(不可读,不存在则创建,存在则抱错)
  a,追加模式(可读,不存在则创建,存在则只追加内容)
  +,表示可以同时读写某个文件 r+ w+ x+ a+
  b,表示以字节的方式操作 rb wb xb ab
  文件读取
  f=open(‘xxx’,‘r’,encoding=“utf-8”)
  f.read()读取文件 f.readline()读取一行
  文件的写入(类型为字符串)
  f=open(‘xxx’,‘a’,encoding=“utf-8”)
  f.write(‘xxx\n’) 写入文件
  f.writelines() 写入列表
  f.close() 关闭文件

• 装饰器
  装饰器，用于装饰某个函数，或者方法，或者类
  装饰可以用于某个函数或者方法或者类在执行之前或者执行后做某些操作，也可以理解为，为某个函数或者方法或者类添加功能
  好处：是不用改变原来的函数，就可以给原来的函数添加功能
  方法：
  1，定义一个函数，里面传一个值用于接收被装饰函数的名称（叫做装饰器函数）
  2，在装饰器函数里定义一个函数（叫做装饰器功能函数）来写添加功能和执行被装饰函数
  3，在装饰器功能函数return返回被装饰函数给装饰器功能函数，并且在装饰器函数return返回装饰器功能函数给装饰器函数
  4，在被装饰函数上面写上 @装饰器函数名 就可以调用执行装饰器函数
  重点：只要函数应用上了装饰器，那么函数就会被重新定义，重新定义为装饰器的内层函数，装饰器内层函数的返回结果就等于应用了装饰器的函数结果
  #装饰器函数
  def zh(sh): #接收被装饰函数的名称
  def zhshi(): #装饰器功能函数
  print(“在执行被装饰函数前添加功能”)
  r = sh() # 执行装饰器函数接收到的被装饰函数，也就是执行被装饰函数
  print(“在执行被装饰函数后添加功能”)
  return r #将被装饰函数执行的结果返回给装饰器功能函数
  return zhshi #将装饰器功能函数名称返回给装饰器函数

  @zh # @zh 的意思是执行装饰器函数，并且将被装饰的函数名，当做参数传给装饰器函数
  def f1():
  print(“f1被装饰函数功能”)
  f1()

  在执行被装饰函数前添加功能

  f1被装饰函数功能

  在执行被装饰函数后添加功能

• 面向对象
  类：描述具有相同的属性和方法的对象的集合，定义了该集合中每个对象所共有的属性和方法，对象是类的实例。
  对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
  类对象：
  class MyClass:
  i = 12345
  def f(self):
  return ‘hello world’
  # 实例化类
  x = MyClass()
  # 访问类的属性和方法
  print(“MyClass 类的属性 i 为：”, x.i)
  print(“MyClass 类的方法 f 输出为：”, x.f())
  构造方法：
  init()方法,类的实例化操作会自动调用 init() 方法
  class Complex:
  def init(self, realpart, imagpart):
  self.r = realpart
  self.i = imagpart
  x = Complex(3.0, -4.5)
  print(x.r, x.i) # 输出结果：3.0 -4.5
  类的继承：
  class people:
  def init(self,n,a,w)
  class student(people):
  def init(self,n,a,w,g):
  #调用父类的构函
  people.init(self,n,a,w)
  self.grade = g
  类的属性可以增、删、改、查 实例的属性可以增、删、改、查
  __两个下划线开头声明该属性或方法为私有不能在类的外部被使用或直接访问
  super().函数名 可以调用父类的方法

• MySQL数据库
  import pymysql

  打开数据库连接

  conn = pymysql.connect(“localhost”,“testuser”,“test123”,“TESTDB” )

  使用cursor()方法获取操作游标

  cursor = conn.cursor()

  SQL 删除语句

  sql = “DELETE FROM EMPLOYEE WHERE AGE > ‘%d’” % (20)
  try:
  # 执行SQL语句
  cursor.execute(sql)
  # 提交修改
  conn.commit()
  except:
  # 发生错误时回滚
  conn.rollback()

  关闭连接

  conn.close()

  取出数据

  ret=cursor.execute(‘select * from test’)
  cursor.fetchmany(3)/cursor.fetchall()/cursor.fetchone()

• 发送邮件
  import smtplib
  from email.mime.text import MIMEText

  邮件服务器

  mail_server = ‘smtp.qq.com’

  用户名

  mail_username = ‘1337983798@qq.com’

  密码，通过环境变量获取，可以避免隐私信息的暴露

  或授权码，QQ邮箱需要使用授权码

  mail_password = ‘eqaoqhrtffngigia’

  邮件内容

  content = ‘请点击右边链接已完成激活’

  创建用于发送的邮件消息对象

  参数1：邮件内容

  参数2：内容类型，plain表示普通文本，html表示网页

  message = MIMEText(content)

  设置主题

  message[‘Subject’] = ‘账户激活’

  设置发送者

  message[‘From’] = mail_username

  创建用于发送邮件的对象

  SMTP：邮件不加密，端口25

  SMTP_SSL：邮件加密传输，端口465，QQ邮箱必须使用加密

  mail = smtplib.SMTP(mail_server)

  身份认证

  mail.login(mail_username, mail_password)

  发送给谁

  to = ‘1337983798@qq.com’

  发送邮件

  mail.sendmail(mail_username, to, message.as_string())

  结束

  mail.quit()

• 同步异步/阻塞非阻塞
  老张爱喝茶，废话不说，煮开水。
  出场人物：老张，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。
  1 老张把水壶放到火上，立等水开。（同步阻塞）
  老张觉得自己有点傻
  2 老张把水壶放到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）
  老张还是觉得自己有点傻，于是变高端了，买了把会响笛的那种水壶。水开之后，能大声发出嘀~~~~的噪音。
  3 老张把响水壶放到火上，立等水开。（异步阻塞）
  老张觉得这样傻等意义不大
  4 老张把响水壶放到火上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）
  老张觉得自己聪明了。

  所谓同步异步，只是对于水壶而言。
  普通水壶，同步；响水壶，异步。
  虽然都能干活，但响水壶可以在自己完工之后，提示老张水开了。这是普通水壶所不能及的。
  同步只能让调用者去轮询自己（情况2中），造成老张效率的低下。

  所谓阻塞非阻塞，仅仅对于老张而言。
  立等的老张，阻塞；看电视的老张，非阻塞。
  情况1和情况3中老张就是阻塞的，媳妇喊他都不知道。虽然3中响水壶是异步的，可对于立等的老张没有太大的意义。所以一般异步是配合非阻塞使用的，这样才能发挥异步的效用

• 线程
  import threading
  def Hi(num):
  print(num)
  t = threading.Thread(target=Hi,args=(10,)) #创建一个线程对象
  t.setDaemon(True) # 守护线程
  t.start() # 开启线程
  t.join() # 线程执行完毕后向下执行

• 进程
  from multiprocessing import Process
  import time
  def f(name):
  time.sleep(2)
  print(‘hello’, name)

  if name == ‘main’:
  p = Process(target=f, args=(‘bob’,))
  p.start()
  p.join()