三：python數據類型和文件操作

一：字符串操作

1.字符串是可以通過下標來進行取值的，但是由於字符串是不可變變量，不能通過下標來修改它的值

  username = 'li'

  username[0] 

2.python里面的for循環，每次循環的時候，循環的是循環對象里面的每一個元素

3.len(names)#取變量的長度 

4.#!/usr/bin/python #python里面有個這個話，代表在linux下運行的時候，去哪個目錄下找python的解釋器，在windows上運行不用寫 

5.# coding:utf-8

　# __*__ coding:utf-8 __*__

 以上這兩種都在python2里面為了防止中文報錯，修改字符集用的，python3里面不用寫 

6.所有字符串的方法，它都不會修改原來字符串的值，都會產生一個新的字符串

7.強制類型轉換函數

#int()  ＃整形
#float()  ＃浮點型
#str()  ＃字符串
#list()  ＃列表
#tuple()  ＃元組

#dict()  ＃字典

8.必須要知道、會的字符串方法

import string

＃print(string.ascii_letters+string.digits)#大小寫字母+數字

＃print(name.find('sss'))＃查找字符串的索引,找到的話返回第一次出現的索引，找不到返回-1

＃print(name.format(name='niuniu', age=18))#格式化字符串

＃print('abA123'.isalnum()) # 是否包含數字和字母

＃print('122'.isdigit()) # 是否是數字

＃print(name.lower()) # 變成小寫

＃print(name.upper()) # 變成大寫

＃strnames = 'ABCEDF'

＃print('￥'.join(strnames))# join是用來通過某個字符串拼接一個可迭代對象的的每個元素的 

 

# print('\nmysql \n'.strip()) # 默認去掉兩邊邊的空格和換行

# print('mysqlm '.strip('m'))#當你傳入某個字符串的話，它就只會去掉你指定的字符串

＃print(st.replace('mysql', 'oracle')) # 替換字符串

＃name1 = 'zcl p y zyz'

print(name1.split())#切割字符串，返回一個list，按照你指定的字符串去分隔這個字符串，然后放到一個list里面，如果你什么都不寫的話，按照空格分割，多個空格也算一個 

9.字符串方法

name = 'heLLo world'
import string
print(string.ascii_letters+string.digits)#大小寫字母+數字
print(string.ascii_lowercase)#所有的小寫字母
print(string.ascii_uppercase)#所有的大寫字母
print(string.digits)#所有的數字
# print(name.capitalize()) # 首字母大寫
# print(name.center(5, '*')) # 50個-，把name放中間
# print(name.endswith('d')) # 是否以x結尾
# print(name.find('sss'))
# 查找字符串的索引,找到的話返回第一次出現的索引，找不到返回-1
# print(name.format(name='niuniu', age=18)) # 這個是格式字符串，再第一節的博客里面已經寫了
# print(name.format_map({'name': 'niuniu', 'age': 19})) # 這個也是格式化字符串，后面跟的是一個字典，字典在后面也會寫
# print('abA123'.isalnum()) # 是否包含數字和字母
# print('abA'.isalpha()) # 是否是英文字母

# print('122'.isdigit()) # 是否是數字
# print('11sdf'.isidentifier()) # 是否是一個合法的變量名
# print('aA'.islower()) # 是否是小寫字母
# print('AA'.isupper()) # 是否是大寫字母
# print(name.lower()) # 變成小寫
# print(name.upper()) # 變成大寫
names = ['zcl','py','zyz']

strnames = 'ABCEDF'
# print('￥'.join(strnames))
# print('strname:',strnames)
# join是用來通過某個字符串拼接一個可迭代對象的的每個元素的

#所有字符串的方法，它都不會修改原來字符串的值，都會產生一個新的字符串
# print('wubing\nhouning')


# print('\nmysql \n'.lstrip()) # 默認去掉左邊的空格和換行
# print('\nmysql \n'.rstrip()) # 默認去掉右邊的空格和換行
# print('\nmysql \n'.strip()) # 默認去掉兩邊邊的空格和換行
# print('mysqlm '.strip('m'))#當你傳入某個字符串的話，它就只會去掉你指定的字符串


# p = str.maketrans('abcdefg', '1234567') # 前面的字符串和后面的字符串做映射
# print('ccaegg'.translate(p)) # 輸出按照上面maketrans做映射后的字符串
#
# new_p = str.maketrans('1234567', 'abcdefg')
# print('ccaegg'.translate(new_p))
st= 'mysql is db. mysql mysql mysql'
print(st.replace('mysql', 'oracle')) # 替換字符串

# print('mysql is is db'.rfind('is')) # 返回最右邊字符的下標

# names = ['zcl','py','zyz']
new_name = []
#1、先得有一個list存它
#2、循環判斷逗號分隔的值
name1 = 'zcl p y zyz'

# print(name1.split())
#切割字符串，返回一個list，按照你指定的字符串去分隔這個字符串，然后放到一個list里面
#如果你什么都不寫的話，按照空格分割，多個空格也算一個

# print('1+2+3+4'.split()) # 切割字符串，返回一個list
# print('1+2+3\n1+2+3+4'.splitlines()) # 按照換行符分割
# print('Abcdef'.swapcase()) # 大小寫反轉

a = 0
b = 2
#不引入第三個變量
a = a+b
#a是3

b = a-b
#b是1
a = a-b
#a是2
print('=====這里才是咱們要看的')
print(a,b)

#引入第三個變量的方法
# c = a
# #c是1
# a = b
# #a是2
# b = c
# print(a,b)

#不用第三方變量，把a和b的值交換過來
# a,b = b,a
# print('a:',a)
# print('b:',b)
a,b = b,a
print('a:',a)
print('b:',b)

二、列表操作

1.列表是可變變量，它是可以通下標修改值的

  names = [1,2,3,"liliyun",'panyang']#定義列表

  # print(names[3])#通過下標取值

  names[0]='zhangyizhou'#修改值

  names.append('zhaocunlei')#給list從最末尾添加值

  names.insert(0,'yinwenqiao')#指定位置添加元素

  # print('before ',names)

  # print('pop返回值:',names.pop())

  # print('remove 方法的返回值',names.remove('yinwenqiao'))

  # del names[0]#使用del關鍵字刪除指定元素

  # names.pop()#默認刪除最后一個元素，刪誰也把它的值返回了

  # names.pop(2)#刪除指定位置的元素

  # names.clear()#清空列表

  # names.remove('yinwenqiao')＃刪除指定的值，要和pop方法區別開來，pop如果刪除的話，傳是下標，

  # reomve傳的是一個元素的值

  # print(names.count('hsdfsdf'))#查找值在list里面的次數

  # print('names',names)

  # print(names.index('yinwenqiao'))#返回查找元素的下標，如果有多個話返回第一個的，如果沒有的話就會報錯

  # print(names.index('yinwenqiao',3,4))#后面可以加上查找開始位置和結束位置

  stus = ['yangwb','yangwn','yanghj']

  # print('加起來的',stus+names)#兩個列表合並

  # print('這個是extend：',stus.extend(names))#把另一個列表里面的每個值挨個添加到前面的列表中

  # print('這個是extend：',stus)

  # nums = [23,34,21,2,456,35,12324324]

  # nums.sort()#排序，默認是升序

  # print('sort：',nums)

  # print(nums.sort(reverse=True))#排序，指定reverse=True就是降序

  # print('sort降序：',nums)

  # print(nums.reverse())

  # print(nums)

  # print('zhangyizhou' in names)#用in來判斷一個元素是否在list里面

  # print(names[-3])#下標是-1的話，代表最后一個元素

 

  #循環列表 

  # for name in names:

  # print(name)

 

  #多維數組、列表、list

  lis = [1,'lily',19.8,['lily','lilei',['heheh','haha']]]

  print(lis[3][2][1])

  a1 =[1,2,3]

  a2 = [4,5,6]

  # a1.extend(a2)

  a1.append(a2)

  print(a1)  

 三、切片

切片的意思就是從list里面或者字符串里面取幾個元素
切片操作對字符串也是完全適用的

name1 = 'zcl,pyzyz'
names = ['zcl','py','zyz']
# print(names[0:2])# 從第幾個取到第幾個，這個也是顧頭不顧尾
# print(names[:2])# 如果是從第一個開始取，取到某一個下標結束，那么最前面是可以不寫的
# print(names[1:])#如果是從前面某個開始取，取到最后面結束，那么最后面是可以不寫的
# print(names[:])#如果最前面和最后面都不寫的話，取整個列表

#nums = list(range(1,11))
# print(nums[1:10:2])#如果最后面寫上步長的話，就是每隔幾個取一次
# nums.reverse()
print(nums)
print(nums[::2])
print(nums[::-2])
print(nums[::-1])
#當切片的步長為負數時，是從末尾開始取值的,然后隔幾個取一次
#如果步長為-1的時候，還有反轉的功能

 四、元組

 

lis = ['127.0.0.1','3306']
tp = (1,2,3,4,5,6,1,1,1)
lis[1]='3307'
print(lis)
print(tp[0])
print(tp.count(1))
print(tp.index(1))
#元組是一個不可變的list,只有count方法和index方法
#定義元組的時候，如果元組只有一個元素，那么你要在這個元素后面，加一個逗號，要不然就是一個字符串
new_lis = tuple(lis)
print(type(new_lis))
a='hello world' #這個是定義字符串
b=('hello world',) #這個是定義元組？
print('this is',type(b))

五、字典

1.字典里面的key是不能重復的

info = {
'name':'xiaoming',
'sex':'nan',
'age':20,
'id':1,
}

# print(info['id'])#通過key取值
# print(info['addr'])#通過key取值
# print(info.get('id'))#通過key取值
# print(info.get('addr'))#通過key取值
2.用中括號取值和get方法取值的區別 ，get方法獲取不到key的時候，不會報錯，中括號取值找不到key會報錯，get方法還可以多傳一個參數，如果get不到key的話，那么返回xx，如果不寫的話，默認get不到返回None
info['addr'] = 'Beijing'#給字典新增一個值
info.setdefault('phone',13811111)#給字典新增一個值
info['id'] = 7#在有這個key的情況下那就是修改這個key的value，沒有這個key的話，就是新增
3.字典是無序的
# del info['addr']
# print(info.pop('addr'))
# info.popitem()#隨機刪除一個元素
# print(info)
#pop刪除的時候必須得指定key，pop方法會返回刪除的key對應的value
# info.clear()
#清空字典

all = {
'car':
{
'color':['red','yellow','black'],
'moeny':1111111,
'pailiang':"2.5L",
'name':"BMW"
} ,
'car1':
{
'color':['red','yellow','black'],
'moeny':1111111,
'pailiang':"2.5L",
'country':"china"
},
'car2':
{
'color':['red','yellow','black'],
'moeny':1111111,
'pailiang':"2.5L"
}

}
# all.get('car').get('color')[1] = 'orange'
# all['car']['color'][1]='orange'
# print(all)

# print(all.keys())#獲取該字典的所有key
# print(all.values())#獲取該字典所有的value
# print(all.items())#獲取字典的key和value，循環的時候用
#直接循環字典循環的是字典的key，如果想循環的時候同時獲取到key和value
#那么就要用.items方法
info2 = {
'name':"hhh",
'sex':'nan'
}
info.update(info2)#把兩個字典合並到一起，如果有一樣的key，那么更新value
# print(info)
# print(info2.items())
#items方法的作用就是為了讓你循環的時候同時把key和value取到
# for k,v in info.items():
# print('%s is %s'%(k,v))
# for k in info2:
# print(k)

# for k in info2:
# print(k,info2[k])

#第二種方式效率比較高
#info.has_key('name')
#python2里面有這個方法，是判斷key是不是存在的，python3里面沒有
# print('name' in info2)
#python3里面直接用in來判斷key是否存在

六、文件讀寫

1、先打開文件
2、讀取/寫入內容
3、保存文件
import os
f = open('a.txt','a+',encoding='utf-8')#f代表的是這個文件的對象，也叫句柄
f.seek(0)#移動文件指針
#文件對象也是可迭代的
# count = 0

#直接循環文件對象的話，循環的是文件每一行的內容
# res = f.read()
# f.seek(0)
# f.truncate()#清空文件內容
# new_res = res.replace('nihao','nibuhao')
# f.write(new_res)
#8G的文件

#下面這些是修改文件內容的
# f = open('a.txt','a+',encoding='utf-8')
# #f代表的是這個文件的對象，也叫句柄
# f.seek(0)#移動文件指針
# fw = open('a.txt.new','w',encoding='utf-8')
# for line in f:
# new_res = line.replace('學','不學')
# fw.write(new_res)
# f.close()
# fw.close()
# os.remove('a.txt')
# os.rename('a.txt.new','a.txt')

# print(f.read())#讀文件內容，返回的是一個字符串
# print(f.readlines())##讀文件內容，返回的是一個列表
# print(f.readline())#只讀文件一行的內容
# f.write('zhangyizhou')#寫文件的時候，只能是字符串
# f.writelines(['123','456','789'])#可以把列表寫到里

#如果在打開的文件的時候，不指定模式，那就是讀模式
# fw = file('a.txt','r')
#在python2里面也可以用file這個函數去操作文件，但是在python3里面只能用open

#文件打開模式有3種
#1、w寫模式，它是不能讀的,如果用w模式打開一個已經存在的文件，
#會清空以前的文件內容，重新寫
#w+，寫讀模式，只要沾上w，肯定會清空原來的文件
#2、r讀模式，只能讀，不能寫，而且文件必須存在
#r+是讀寫模式,只要沾上r，文件必須得存在
#3、a追加模式，也是只能寫，在文件的末尾添加內容
#4、rb+、wb+，ab+,這種是二進制模式打開或者讀取，一些音樂文件、圖片等等

#flush用法
import time
fw = open('python.txt','w',encoding='utf-8')
fw.write('下周不上課！')
fw.flush()#寫完之后立馬生效
exit('拜拜')
time.sleep(30)
fw.close()


#with的用法，你文件不再用的時候，就會自動給你關閉文件
# with open('python.txt',encoding='utf-8') as fr:
# print(fr.read())

六、重定向

＊＊重定向可快速清空一個文件內容
一下為幾個Linux命令：
cat a.txt > b.txt 把a中的內容清空放到b中
rm -rf b.txt 刪除b.txt
touch b.txt 建一個新文件b.txt
cat > b.txt

＊＊下面是一個小程序：

寫一個程序，監控nignx的日志，如果有人攻擊你，就把他的IP地址加入黑名單：

把IP加入黑名單的策略是，1分鍾之內，如果同一個IP地址，請求次數超過200，那就加入黑名單

思路：

1⃣️：讀文件

2⃣️：字符串分割、list的統計次數

3⃣️：把IP加入黑名單，執行Linux命令

4⃣️：切割日志

重定向即把一個文件里面的內容，復制到另一個文件里面

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

import time
while True:
    ips = []
    #存放所有的ip地址
    with open('access.log','a+') as fr:
        fr.seek(0)
        for line in fr:
            ip = line.split()[0]            ips.append(ip)        fr.seek(0)
        fr.truncate()
    print('ips,長度：',len(ips))
    ip_set = set(ips)#存放的是去重之后的ip地址
    print('去重之后的ip_set的長度：',len(ip_set))
    for ip in ip_set:
        if ips.count(ip)>200:
            print('已經把%s加入黑名單'%ip)
            # os.system('iptables -I INPUT 1 -p tcp -s %s  -j DROP'%ip)
    time.sleep(60)

七、三元運算符

a = 1
b = 2
#下面這個
c = a if a>1 else b

#和下面是一樣的效果
if a > 1:
    c = a
else:
    c = b

#第一種
# s = []
# nums = list(range(1,11))#list顧頭不顧尾，所以取值為1-10
# for i in nums:
#     if i%2 == 0:
#         s.append(i)
# print(s)
# 第二種
# ss = [i for i in nums if i%2 == 0]
# print(ss)
這兩種是一樣的

八、集合

1.集合也是一種數據類型，一個類似列表東西，他的特點是無序的，不重復的，也就是說集合中是沒有重復的數據
2.無序不能根據下標取值
3.set是集合，集合是天生可以去重的
eg：
# d = {'id':1,'phone':138}#這是字典
# l = {1,2,2,3,3,4}#這是集合
# s = set(l)#強制類型轉換，把list轉成集合
# for i in s:
# print(l)
4.定義集合
# nums = [1,1,1,1,1,13,33]
# num_set = set(nums)
# 通過強制類型轉換來定義集合
# print(num_set)
# list1 = {1,2,3,4,5,6,8}
# list2 = {2,3,4,6,1}
# list3 = {1,2,3}
# print(list1.intersection(list2)) # 取交集，也就是取list1和list2中都有的
# print(list1 & list2)# 取交集
# print(list1.union(list2)) # 取並集，也就是把list1和list2合並了，然后去除重復的
# print(list1 | list2)# 取並集
# print(list1.difference(list2)) #取差集 在list中存在，在list2中沒有的
# print(list1 - list2) #取差集 在list中存在，在list2中沒有的
# print(list3.issubset(list1))#判斷list3是不是list1的子集
# print(list1.issuperset(list3))#判斷list1是不是list3的父集
# print(list1.isdisjoint(list3))#判斷list1和list3是否有交集
# print(list1.symmetric_difference(list2))#對稱差集，輸出兩個列表中都沒有的值，也就是把兩個集合中相同的去掉
# print(list1 ^ list2)#對稱差集，輸出兩個列表中都沒有的值，也就是把兩個集合中相同的去掉
# list1.add(888)#添加元素
# list1.update([777,666,666])#添加元素
# list1.remove(777)#刪除元素，如果元素不存在會報錯
# list1.pop()#刪除一個隨機的元素，並返回刪除的元素
# list1.discard('dddd')#如果刪除的元素存在，刪除，不存在不做處理