二、基础—常用数据结构：列表、元祖、集合、字典、函数等（爬虫及数据可视化）

1，字符串

字符串，截取，连接，输出，重复打印直接*，r等原始字符不变
做数据处理时，大部分都是以字符串存在的
有很多的库等，字符串的截取等操作
在python中所有代码默认是UTF-8的
日常还是建议使用双引号，比较常用
转义字符关注一些即可，如想要输入一个斜杠\，需要\\
在网络爬虫时，可能爬取的文档内容包含一些单引号或双引号等，需要进行转义再进行数据库的存储和显示，否则会出现问题

\\
\’
\”
\n
\t

当爬虫时爬取的文本很长，需要将一些文字截取出来，有一个函数str可以做列表的方式访问

print(r'hello\npython') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

在后面爬虫会经常用到r，所有的\等不进行解释直接输出，将别人爬取出的文字内容，最好在前面加个r这样中间的内容全部保存下来，显示到网页也是可以保存原来的格式的

str='chengdu' 
print(str) # 输出字符串 
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 
print(str[0]) # 输出字符串第一个字符 
print(str[2:5]) # 输出从第三个开始到第五个的字符 
print(str[2:]) # 输出从第三个开始后的所有字符 
print(str * 2) # 输出字符串两次 
print(str + '你好') # 连接字符串 
print(str[:5]) # 输出第五个字母前的所有字符 
print(str[0:7:2]) # [起始：终止：步长] 
print('------------------------------') 
print('hello\nchengdu') # 使用反斜杠(\)+n转义特殊字符 
print(r'hello\npython') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

字符串常见操作：
isdigit() 等可以判断是否是一个数字
join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
lstrip() 截掉字符串左边的空格或指定字符。去除空格等在爬虫时经常用，有些文字有空格，需要去掉再进行存储，有利于计算
isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回False
join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

2，最常用的是列表（重点掌握）

列表、元组、字典、集合

列表的使用非常像数组，但不同在于里面的类型可以是不同的

很多爬虫爬取的数据都会在内存中存一下，梳理好后再放到数据库中

学数据结构或者数据库本质在讨论如何高效的管理数据

数组、列表等都是如何对数据进行增删改查、排序等
无论作业，还是爬虫3.2.3的常用操作都会用到

具体使用场景，如在数据库查出了一堆数据，希望排好顺序，不希望再次查询数据库，只希望将页面上存在的内容进行升序降序，可以不用在访问数据库，直接内存操作即可

#-*- codeing = utf-8 -*- 
#@Time : 2020/11/18 18:59
#@Author : 招财进宝
#@File : demo2.py
#@Software: PyCharm

namelist =["小王","小李","小张"]
'''
namelist =["小王","小李","小张"]
print(namelist[0])
print(namelist[1])
print(namelist[2])

namelist =[1,"小李"]
print(namelist[0])
print(type(namelist[0]))
print(namelist[1])
print(type(namelist[1]))
'''

'''
namelist =[1,"小王","小李","小张"]
for name in namelist:                   #此种方法常用需要学会使用
    print(name)


#while代码可能多一点，使用的是下标，但有些时候我们需要使用下标和其他的结合的
length=len(namelist)
i=0
while i<length:
    print(namelist[i])
    i+=1
'''

'''
print("-----增加前，名单列表的数据----")
for name in namelist:
    print(name)

#append  增加
nametemp = input("please input name:")
namelist.append(nametemp)

print("-----增加后，名单列表的数据----")
for name in namelist:
    print(name)
'''

'''
a=[1,2]
b=[3,4]
a.append(b)         #会将b列表作为一个整体元素放倒a列表中，形成了列表的嵌套
print(a)

a.extend(b)         #会将b列表中的每个元素，逐一追加到列表中
print(a)
'''

'''
#增：  [insert]插入
a =[0,1,2]
a.insert(1,3)       #第一个变量表示下标，第二个表示元素（对象）
print(a)            #指定下标位置插入元素
'''

'''
#删  [del] [pop]

movieName = ["加勒比海盗","海尔客帝国","第一滴血","指环王","速度与激情"]
print("-----删除前，名单列表的数据----")
for name in movieName:
    print(name)

#del movieName[1]       # 在指定位置删除一个元素
#movieName.pop()         #弹出末尾最后一个元素
movieName.remove("指环王")     #直接删除指定内容的元素(当有两个重复数据时，删除的是找到的第一个元素)

print("-----删除后，名单列表的数据----")
for name in movieName:
    print(name)
'''

'''
#改：
print("-----增加前，名单列表的数据----")
for name in namelist:
    print(name)

namelist[1]="小红"        #修改指定下标的元素内容

print("-----增加后，名单列表的数据----")
for name in namelist:
    print(name)
'''

'''
#查：不是搜索，主要是判断元素是否在列表中【in ,not in】

findName = input("请输入你要查找的学生姓名：")

if findName in namelist:                        #不是for in循环，而是if判断某个元素在列表中
    print("在列表中找到了学生的名字")
else:
    print("没有找到")
'''

'''
# 查 查找指定下标范围的元素并返回对应数据的下标
mylist=["a","b","c","a","b"]

mylist.index("a",1,4)            #查询元素“a”是否在第1到4的位置上出现(不包含4)，范围区间左闭合，右断开【1,4）
print(mylist.index("a",1,4) )    #能将查到的下标得到

print(mylist.count("c"))        #统计某个元素出现几次
'''

'''
#具体使用场景，如在数据库查出了一堆数据，希望排好顺序，不希望再次查询数据库，只希望将页面上存在的内容进行升序降序，可以不用在访问数据库，直接内存操作即可
a=[1,4,2,3]
print(a)
a.reverse()                 #将列表所有元素反转
print(a)
a.sort()                 #升序，将列表所有元素从低到高排序
print(a)
a.sort(reverse=True)          #降序，将列表所有元素从高到低排序
print(a)
'''

schoolNames = [[],[],[]]        #有三个元素的空列表，每个元素都是一个空列表

#嵌套的列表大学可以不同
schoolName = [["北京大学","清华大学"],["南开大学","田径大学","田径师范大学"],["山东大学","中国海洋大学"]]

print(schoolName[0])
print(schoolName[0][0])


#3个办公室，8个老师，随机将其分配到教师
import random
offices=[[],[],[]]
names = ["A","B","C","D","E","F","G","H"]

for name in names:
    index = random.randint(0,2)     #[0,2]
    offices[index].append(name)

i=1
for office in offices:          #遍历得到每个办公室
    print("办公室%d的人数：%d"%(i,len(office)))
    i+=1
    for name in office:         #遍历得到每个办公室的人名
        print("%s"%name,end="\t")
    print("\n")
    print("-"*20)

嵌套、追加、len、双层for循环等

作业：商品（重要必看）

你所购买的商品有：
共几件，总价是

#作业   打印商品列表
products = [["iphone",6888],["MacPro",14800],["小米6",2499],["Coffee",31],["Book",60],["Nike",699]]

'''
#for productIndex in len(products):
i = 0
for product in products:
    print(i,end="\t")
    for col in product:
        print(col,end="\t")
    print("")
    i+=1
'''

buyProducts = []
while True:
    #用于循环输出商品
    for i,product in enumerate(products):       #使用枚举函数enumerate()可以同时拿到列表的下标和元素内容
        print(i, end="\t")
    for col in product:
        print(col, end="\t")
    print("")


    indexStr = input("想要买什么商品，请选择商品编号：")
    #判断输入的是否为数字
    if indexStr.isnumeric():                   #判断字符串是否为数字字符isnumeric()
        pass                                #主要用来占位，无任何操作
    else:
        print("请输入数字")
        continue                            #进入下一循环，或者break

    #判断输入的数字是否在编号内
    index = int(indexStr)
    if (index>0 and index<len(products)):
        pass
    else:
        continue

    #此处是在尾后追加
    tempProduct=[]
    tempProduct.append(index)                       #将整体元素追加
    tempProduct.extend(products[index])             #将列表中的元素追加
    buyProducts.append(tempProduct)                 #【【1，MacPro,14800】】得到类似此的列表

    #判断是否退出
    isQ=input("是否退出（退出q/继续y）：")
    if isQ=="q":
        break

#退出后打印保存的商品信息
sumMoney=0
print("你所购买的商品有如下：")
for product in buyProducts:
    sumMoney+=product[len(product)-1]
    for col in product:
        print(col, end="\t")
    print("")
    i += 1

print("共%d件，总价是%d。"%(len(buyProducts),sumMoney))

3，元组

元组并不是很重要的简单看看即可

主要看课件
Tuple 中元素不能修改，写法也不同，小括号

定义tuple类型时，需要使用“，”隔开 如 t1=（1，）
否则会将t1认为是1的类型，而不是元组的类型

元组的操作可查看课件

#-*- codeing = utf-8 -*- 
#@Time : 2020/11/19 9:39
#@Author : 招财进宝
#@File : demo3.py
#@Software: PyCharm

#此章节主要是元组

'''
tup1 = ()       #创建空的元组
print(type(tup1))           #tup类型<class 'tuple'>

tup2 = (50)     #当只有一个数据时，不是元组类型，而是整型的<class 'int'>
print(type(tup2))

tup3 = (50,)     #在数据后面加入“，”就是元组的类型了
print(type(tup3))

tup3 = (50,)     #在数据后面加入“，”就是元组的类型了
print(type(tup3))
'''

'''
tup1 = ("abc","def",2000,2000,333,444,555)

print(tup1[0])
print(tup1[-1])         #-1表示最后一个
print(tup1[1:5])        #切片，左闭合，右开放
'''

#增
#表面上是增加的过程，实际没有修改，而是连接了
'''
tup1 = (1,2,3)
tup2 = ("abc","def")

tup = tup1+tup2
print(tup)
'''

#删
tup1 = (1,2,3)
print(tup1)
del tup1          #删除整个元组变量，而不是删除其中某个元素
print("删除后：")
print(tup1)         #会报错，无定义，前面讲元组变量删除了

#改
tup1 = (1,2,3)
#tup1[0]=100   报错不能修改

#查

4，字典（重要）

字典存储的是键值对（重点）
为了保证想要查询一个键时能快速找到一个值的功能而涉及的

字典中前面的键必须唯一，值可以重复
键必须是不可变的类型，一旦存入，不得更改

字典的定义如下，有键有值，形成键值对

info = {"name":"吴彦祖","age":18}

#-*- codeing = utf-8 -*- 
#@Time : 2020/11/19 10:18
#@Author : 招财进宝
#@File : demo4.py
#@Software: PyCharm


#此处主要是字典

'''
#字典的定义
info = {"name":"吴彦祖","age":18}

#字典的访问(通过键找值)
print(info["name"])             #直接访问
print(info["age"])
print(info.get("name"))         #get寻找，无找到会返回none

#访问了不存在的键
#print(info["gender"])       直接访问，会报错

print(info.get("gender"))       #使用get方法，没有找到对应的键，默认返回None
print(info.get("gender","m"))       #没找到的时候，可以设定默认值
print(info.get("age","m"))          #找到了默认值不生效
'''


#字典也是一个数据结构，也需要增删改查

#增
'''
info = {"name":"吴彦祖","age":18}
newID = input("please input newID:")
info["id"] = newID

print(info)
'''

#删
# del 删
'''
info = {"name":"吴彦祖","age":18}
print("删除前：",info)

#删除键值对后，再直接访问不存在的键会报错，可以get寻找
del info["name"]                        #此处不仅删除键的值，连键也删除了
print("删除后：",info)
'''

'''
info = {"name":"吴彦祖","age":18}
print("删除前：%s"%info)                #此种写法也可以

#删除键值对后，再直接访问不存在的键会报错，可以get寻找
del info                       #直接将字典删除了，字典变量从内存中清除了
print("删除后：%s"%info)
'''
#clear 清空（清空字典内的数据，是字典为空，而不是将整个字典删除）
'''
info = {"name":"吴彦祖","age":18}
print("清空前：%s"%info)                #此种写法也可以

#删除键值对后，再直接访问不存在的键会报错，可以get寻找
info.clear()                       #直接将字典删除了，字典变量从内存中清除了
print("清空后：%s"%info)
print(type(info))                   #<class 'dict'>
'''

#改
'''
info = {"name":"吴彦祖","age":18}

#直接通过键访问
info["age"]=20
print(info["age"])
'''

#查
'''
info = {"id":1,"name":"吴彦祖","age":18}
print(info.keys())          #得到所有的键（列表形式），若对单个键进行操作，可以对列表的方式操作即可dict_keys(['id', 'name', 'age'])
print(info.values())        #得到所有的值dict_values([1, '吴彦祖', 18])

print(info.items())        #得到所有的项（列表），每个键值对是一个元组dict_items([('id', 1), ('name', '吴彦祖'), ('age', 18)])

#遍历所有的键
for key in info.keys():
    print(key)

#遍历所有的值
for value in info.values():
    print(value)

#遍历所有的键值对
for key,value in info.items():      #会自动将项中元组的元素赋值给key和value
    print("key=%s,value=%s"%(key,value))
'''

mylist = ["a","b","c","d"]

for x in mylist:        #此处可以拿到每个元素
    print(x)
#但我们既想拿到元素，又想拿到下标，怎么办

#可以使用枚举函数，能同时拿到列表中的下标和元素内容
for i,x in enumerate(mylist):        #此处可以拿到每个元素
    print(i,x)

5，集合

集合不是重点
简单过一下

仅仅是键集合
在集合只有键没有值，可以用于去重的作用

6，函数（重要）

如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独 立功能的代码块组织为一个小模块，这就是函数。

课堂练习：
1.写一个打印一条横线的函数。（提示：横线是若干个“-”组成）
2.写一个函数，可以通过输入的参数，打印出自定义行数的横线。（提示：调用上面的函数）
3.写一个函数求三个数的和
4.写一个函数求三个数的平均值（提示：调用上面的函数）
【建议每题5分钟以内】

#-*- codeing = utf-8 -*- 
#@Time : 2020/11/19 14:21
#@Author : 招财进宝
#@File : demo1.py
#@Software: PyCharm

#函数

'''
#函数的定义（不会被执行）
def printinfo():
    print('------------------------------------')
    print(' 人生苦短，我用Python')
    print('------------------------------------')

#函数的调用
printinfo()
'''

'''
#带参数的函数
def add2Num(a,b):
    c=a+b
    print(c)

add2Num(1,2)
'''

'''
#带返回值的函数
def add2Num(a,b):
    return a+b          #通过return来返回运算结果

result = add2Num(11,12)
print(result)
'''

'''
#返回多个值的函数(需要使用多个值接收)
def divid(a,b):
    shang = a/b
    yushu = a%b
    return shang,yushu          #多个返回值用逗号隔开

sh,yu=divid(5,2)                #需要使用多个值来保存内容
print("商:%d,余数:%d"%(sh,yu))
'''


# 课堂练习：
# 1.写一个打印一条横线的函数。（提示：横线是若干个“-”组成）
# 2.写一个函数，可以通过输入的参数，打印出自定义行数的横线。（提示：调用上面的函数）
# 3.写一个函数求三个数的和
# 4.写一个函数求三个数的平均值（提示：调用上面的函数）
'''
#以下是自己编写的
def printH():
    print("-"*10)

def printHNum(a):
    for i in range(a):
        printH()

def sumThree(a,b,c):
    return a+b+c

def evThree(a,b,c):
    ev = sumThree(a, b, c)/3
    return ev

printH()
printHNum(3)
print(sumThree(1,2,3))
print(evThree(1,2,3))
'''

'''
#下方为练习的答案
# 打印一条横线
def printOneLine():
    print("-"*30)
# 打印多条横线
def printNumLine(num):
    i=0
# 因为printOneLine函数已经完成了打印横线的功能，
# 只需要多次调用此函数即可
    while i<num:
        printOneLine()
        i+=1

printNumLine(3)

# 求3个数的和
def sum3Number(a,b,c):
    return a+b+c # return 的后面可以是数值，也可是一个表达式
# 完成对3个数求平均值
def average3Number(a,b,c):
# 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可
# 即把接收到的3个数，当做实参传递即可
    sumResult = sum3Number(a,b,c)
    aveResult = sumResult/3.0
    return aveResult
# 调用函数，完成对3个数求平均值
result = average3Number(11,2,55)
print("average is %d"%result)
'''

#全局变量和局部变量
'''
#局部变量（出了函数之后就无效了，不会相互影响）
def test1():
    a=300               #局部变量
    print("test1---修改前:a=%d"%a)
    a = 100
    print("test1---修改后:a=%d" % a)

def test2():
    a=500               #不同的函数可以定义相同的名字，彼此无关
    print("test2---:a=%d" % a)

test1()
test2()
'''

'''
a=100   #全局变量

def test1():
    print("test1---:a=%d" % a)

def test2():
    print("test2---:a=%d" % a)      #调用全局变量a

test1()
test2()
'''

'''
#全局变量和局部变量名称相同
a=100   #全局变量
def test1():
    a=300               #局部变量优先使用（test1修改的是自己的变量）
    print("test1---修改前:a=%d"%a)
    a = 200
    print("test1---修改后:a=%d" % a)

def test2():
    print("test2---:a=%d" % a)      #没有局部变量，默认使用全局变量

test1()
test2()
'''

#若就想在函数内访问全局变量，并在函数中将全局变量修改
#需要在局部变量声明一下
a=100   #全局变量

def test1():
    global a              #声明全局变量在函数中的标识符
    print("test1---修改前:a=%d"%a)
    a = 200
    print("test1---修改后:a=%d" % a)

def test2():
    print("test2---:a=%d" % a)      #没有局部变量，默认使用全局变量

test1()
test2()
result = average3Number(11,2,55) 
print("average is %d"%result)