列表名.函数名（对象)

  1.      append：在列表的最后   list.append(value)
  3.     insert：插入到指定位置  list.insert(index,value)
  5.     pop:删除   leave=list.pop(index)  index缺省表示最后一个
  6.     访问：注意是   list[index]

如果想打印列表和字符串相连，则需要对列表用str()

for循环

  1.    for name in list:
  2.      print(name)

索引循环

  1. for index in range(len(list)):
  2. print(str(index)+list[index])

字符串遍历

  1. for char in 'xxxxxxx':
  2.   print(char)

range创建的类型其实是range object,类列表，range（10）表示[0,10） range:range(start,end,step) step为-1时，为倒序

break与continue

  1. break表示跳出这次循环
  2. continue表示忽略这次循环

打印不换行

  1. print('之前', end=' ')
  2. tips:end表示打印之后添加的字符串，默认是\n,这一将其替换为空格

str与list的相互转换

  1. list1=list(str1)

str[satrt:end]

  1. str='abcde'
  2. str[0:2] #结果为ab

字典

python基础 - 图1

字典的访问

  1. dicname['keyname']
  2. (字典通过key进行访问，索引在字典中无意义，区别于列表的有序，字典是无序的
  3. key只要是不变的数据都可以 常见有字符串、数值类型、布尔类型 `列表不行`  `元组可以`)

字典的删除

  1. del dicname[keyname]
  2. 清空： dictname.clear()

字典的遍历

python基础 - 图2

集合Set:非重复的无序列表

元组中的数据只能被读取，不能被修改
列表解决多个有序元素的问题
字典解决描述和值的映射问题
集合：非重复，无序——去重提高运行效率

python基础 - 图3

集合的增加与删除与遍历

  1. heros.add('name')
  2. heros.remove('name')
  3. for hero in heros:

Set的去重应用

9.3的两种做法
一、 不用字典直接输出

  1. import csv
  2. with open('calls.csv', 'r') as f:
  3.   reader = csv.reader(f)
  4.   texts = list(reader)
  6. phone = '16560480842'
  7. # 统计每个相关电话号码的总通话时长
  8. list1=[]
  9. for text in texts:
  10.   if phone==text[0]:
  11.     list1.append(text[1])
  12.   if phone==text[1]:
  13.     list1.append(text[0])#接听de记录
  14. sets=set(list1)      #集合去重的应用
  15. for set1 in sets:
  16.   sum=0
  17.   for text in texts:
  18.     if set1 in text and phone in text:
  19.       sum=sum+int(text[3])
  20.   min=sum//60
  21.   print('通话号码：'+str(set1)+'-总时长：'+str(min)+'分钟')

二、 用字典记录

  1. import csv
  2. with open('calls.csv', 'r') as f:
  3.   reader = csv.reader(f)
  4.   texts = list(reader)
  6. phone = '16560480842'
  7. # 字典存储每个相关号码的通话时长，key为电话号码，value为通话时长
  8. duration = {}
  9. for text in texts:
  10.   callingPhone = text[0]  # 主叫号码
  11.   calledPhone = text[1]  # 被叫号码
  13.   # 判断是否为相关号码
  14.   if phone == callingPhone or calledPhone == phone:
  16.     # 下面三行逻辑，找到另一个号码，有可能是主叫，也可能是被叫
  17.     otherPhone = calledPhone
  18.     if phone == calledPhone:
  19.       otherPhone = callingPhone
  21.     # 如果字典中不存在号码通话总时长，则我们将其设置为0
  22.     if otherPhone not in duration:
  23.       duration[otherPhone] = 0
  25.     # 字典中的通话时长总时长，往上累加
  26.     duration[otherPhone] += int(item[3])
  28. for key in duration:
  29.   print('通话号码：' + key + '-总时长：' + str(duration[key] // 60) + '分钟')

排序笔记及其拓展

  1. '冒泡排序：每次比较相邻的两个，进行交换，多次循环'
  2. #以下保证最上面那个数字为最大数字
  3. nums = [8, 6, 7, 9, 4, 5, 3, 1, 2]
  4. for index in range(len(nums) - 1):
  6.   # 如果底部元素>顶部元素，则交换
  7.   if nums[index] > nums[index + 1]:
  8.     # 交换元素
  9.     temp = nums[index + 1]
  10.     nums[index + 1] = nums[index]
  11.     nums[index] = temp
  13. print(nums[-1])
  14. #……
  15. #以下保证全部
  16. nums = [8, 6, 7, 9, 4, 5, 3, 1, 2]
  17. for time in range(len(nums) - 1):
  18.   # 此处表示循环次数，9个元素，循环8次可以找到最大的8个元素，及完成了排序
  19.   for index in range(len(nums) - 1 - time):
  20.    ' # 注意此处，我们减去time，因此每次顶部的元素已经找到了，不需要再次遍历了'
  22.     # 如果底部元素>顶部元素，则交换
  23.     if nums[index] > nums[index + 1]:
  24.       # 交换元素
  25.       temp = nums[index + 1]
  26.       nums[index + 1] = nums[index]
  27.       nums[index] = temp
  29. print(nums)
  1. '插入排序，有原list跟sort，拿出一个数据，依次跟sort中比对过去，替代或者放在最后（用insertindex==-1来区分）'
  2. nums = [8, 6, 7, 9, 4, 5, 3, 1, 2]
  3. sorts = []
  4. for item in nums:
  5.   # 当有序列表为空时，插入一个元素
  6.   if len(sorts) == 0:
  7.     sorts.append(item)
  8.   else:
  9.     insertIndex = -1;
  10.     for index in range(len(sorts)):
  11.       # 遍历直到当前元素大于将插入的元素
  12.       if sorts[index] > item:
  13.         insertIndex = index
  14.         break
  15.     # 如果insertIndex = -1，也就是全部有序列表中都小于将插入的元素
  16.     # 可以使用append插入到最后
  17.     # 否则利用insert进行插入，并break停止查找
  18.     if insertIndex == -1:
  19.       sorts.append(item)
  20.     else:
  21.       sorts.insert(insertIndex, item)#注意这边做的是插入而不是替换
  22. print(sorts)
  1. '选择排序：从未排列表中找到最值，放到列表首位，之后在剩下的列表中重复以上步骤。时间复杂度 O(n²)'
  2. nums = [8, 6, 7, 9, 4, 5, 3, 1, 2]
  3. for i in range(len(nums)-1):
  4.         # 记录最小数的索引
  5.   minIndex = i
  6.   for j in range(i + 1, len(nums)):
  7.     if nums[j] < nums[minIndex]:
  8.       minIndex = j
  9.         # i 不是最小数时，将 i 和最小数进行交换
  10.   if i != minIndex:
  11.       nums[i], nums[minIndex] = nums[minIndex], nums[i]
  12. print(nums)
  1. '快速排序：从列表中选择一个基准元素，比之大的放到左边，反之右边，再分别对两部分继续执行上述步骤(函数实现递归)'
  2. def sort(data):        
  3.     if len(data) >= 2:     
  4.         mid = data[len(data)//2]  # 选取基准值       
  5.         left, right = [], []  # 定义基准值左右两侧的列表        
  6.         data.remove(mid)  # 从原始数组中移除基准值        
  7.         for num in data:            
  8.             if num >= mid:                
  9.                 right.append(num)            
  10.             else:                
  11.                 left.append(num)        
  12.         return sort(left) + [mid] + sort(right)    
  13.     else:        
  14.         return data

函数定义

python基础 - 图4

动态参数

  1. def cMin(arg1, arg2, *args):
  2.   print(arg1)
  3.   print(arg2)
  4.   print(args) # 注意这里没有*号咯，*号在这里是可变参数的规则表示
  5. cMin(1,2,3,4,5,6)
  6. #结果为
  7. 1
  8. 2
  9. (3, 4, 5, 6)
  11. '我们可以看到args把剩余的参数合并成一个元组'
  1. '把所有连在一起打印'
  2. def cPrint(*args):
  3.   for arg in args:
  4.     print(arg, end=' ')
  6. cPrint('hello', 'my', 'world')
  7. #结果为
  8. hello my world

递归

在处理f(n)的时候，我们假设f(n-1)已经搞定了，于是我们不需要考虑其他，只需要考虑在f(n-1)基础上所增加的内容
  1. '用递归实现阶乘'
  2. # 定义一个递归函数
  3. def fact(n):
  4.   # 加入递归条件
  5.   if n == 1:
  6.     return 1
  7.   # 把fact(n-1)的结果和n相乘，剩下的交给fact(n-1)
  8.   return fact(n-1) * n
  9. fact(10)

模块

  1. '用模块来管理函数'#phone.py 中包含与phone相关的函数
  2. '注意不用加后缀py'
  3. #调用
  4. import xxx
  5. xxx.function()
  6. #直接导入函数
  7.  from xxx import function

平级关系才能使用 python基础 - 图5

pillow

https://www.osgeo.cn/pillow/index.html

  1. from PIL import Image  #从PIL中导入 Image函数
  2. im = Image.open('1.jpg')   #im为变量，用open函数打开图片
  3. out = im.rotate(45)   #对im 使用rotate函数 赋值给 out
  4. out.save('result.jpg')#对 out用save函数，保存

人脸识别实战

截取人脸

  1. # 引入Pillow库
  2. from PIL import Image
  3. # 引入face_recognition的库
  4. import face_recognition
  5. # 用这个库加载1.jpg图片
  6. image = face_recognition.load_image_file('1.jpg')'#注意这边的image的格式只是图片的列表形式的数据'
  7. #  开始进行人脸识别
  8. face_locations = face_recognition.face_locations(image)
  10. top, right, bottom, left = face_locations[0]
  11. origin = Image.open('1.jpg')    '#因此这里需要重新打开一张图片,为节省内存，可以用'
  12. #origin = Image.fromarray(image)'代替'
  13. out = origin.crop((left, top, right, bottom))
  14. out.save('result.jpg')

学习Pillow画图 ImageDraw 

  1. draw = ImageDraw.Draw(im)   # 先用PIL图片创建一个画板，我么叫做draw
  2. draw.line([(0,0), (100, 200), (400, 300)])
  4. origin.save('result.jpg')

获取五官的位置 face_landmarks函数 

  1. from PIL import Image, ImageDraw
  2. import face_recognition
  3. image = face_recognition.load_image_file("1.jpg")  #image是图片的列表形式的数据
  4. #该函数在face_recognition的库下，因此可以直接对 image 做处理
  5. # 获取图片的面部特征位置
  6. face_landmarks_list = face_recognition.face_landmarks(image)
  7. print(face_landmarks_list)
  8. #结果会得到一个列表 列表中有三个字典（以下为key的含义）
  9. chin: 脸轮廓
  10. left_eyebrow: 左眉毛
  11. right_eyebrow: 右眉毛
  12. nose_bridge: 鼻梁
  13. nose_tip: 鼻尖
  14. left_eye: 左眼
  15. right_eye: 右眼
  16. top_lip: 上嘴唇
  17. bottom_lip: 下嘴唇

获取眼睛中点位置

  1. from PIL import Image, ImageDraw
  2. import util
  3. import face_recognition
  4. image = face_recognition.load_image_file("1.jpg")
  5. face_landmarks_list = face_recognition.face_landmarks(image)
  7. # 获取第一个小女孩的五官信息
  8. face_landmarks = face_landmarks_list[0]
  10. # 获取小女孩的左眼信息
  11. left_eye = face_landmarks['left_eye']
  12. right_eye = face_landmarks['right_eye']
  14. leftPoint, rightPoint = util.getLeftRightPoint(left_eye)
  15. leftCenterPoint = util.getCenter(leftPoint, rightPoint)
  17. leftPoint, rightPoint = util.getLeftRightPoint(right_eye)
  18. rightCenterPoint = util.getCenter(leftPoint, rightPoint)
  20. print('左眼中心的点: ' + str(leftCenterPoint) + '右眼中心的点：' + str(rightCenterPoint))

util为自己封装的模块

  1. def getLeftRightPoint(points):
  2.   # 先假设第一个点为需要的点，之后我们再喜欢
  3.   leftPoint = points[0]
  4.   rightPoint = points[0]
  5.   for point in points:
  6.     # 当x更小的时候，更新左侧的点
  7.     if point[0] < leftPoint[0]:    #我们去比较的是他的横坐标，但是我们更新的是整个点
  8.       leftPoint = point
  9.     # 当x更大的时候，更新右侧的点
  10.     if point[0] > rightPoint[0]:
  11.       rightPoint = point
  12.   # 返回一个元组
  13.   return leftPoint, rightPoint
  16. def getCenter(leftPoint, rightPoint):
  17.   return (leftPoint[0] + rightPoint[0]) / 2, (leftPoint[1] + rightPoint[1]) / 2

额头的顶点暂定为 两眼中点往上移动1.2倍的眼间距离

  1. browPoint = (centerPoint[0], centerPoint[1] - (rightCenterPoint[0] - leftCenterPoint[0]) * 1.2)
  2. print('额头的顶部点：' + str(browPoint))

画十字

  1. origin = Image.fromarray(image)
  2. draw = ImageDraw.Draw(origin)
  3. draw.line([(browPoint[0] - 5, browPoint[1]), (browPoint[0] + 5, browPoint[1])])
  4. draw.line([(browPoint[0], browPoint[1] - 5), (browPoint[0], browPoint[1] + 5)])
  6. origin.save('result.jpg')

图片放缩

  1. result=origin.resize((width, height))
  2. # 函数里面的第一个参数是一个元组，表示新的长宽
  3. # 返回一个新的PIL图片
  1. from PIL import Image
  2. im = Image.open('christmas_hat.png')
  3. width, height = im.size  #获取尺寸
  4. resizeImg = im.resize((width // 2, height // 2))
  5. '#注意这里的做法是用  整除  代替  普通除 ，因为resize只能接受整数'
  6. resizeImg.save("thumbnail.png")

图片合成

  1. # 需要合成在大图中的位置，依次是左，上，右，下
  2. box = (100, 100, 400, 400)
  4. # hat为需要合成的图片，origin为大图
  5. origin.paste(hat, box)
  6. '注意合成的图片与box框的大小必须一致，否则会报错'
  1. from PIL import Image
  2. origin = Image.open('1.jpg')
  3. hat = Image.open('christmas_hat.png')
  5. # 将帽子大小缩小到300*300，这样才能与下面的box吻合
  6. resizeHat= hat.resize((300, 300))
  7. # 注意这里第三个参数传入透明通道,去除黑边
  8. origin.paste(resizeHat, (100, 100, 400, 400), resizeHat)
  9. origin.save('merge.jpg')