s = ‘python自動化學習‘
s1 = s[0]
print(s1) #通過索引找到元素

切片：就是一段，【0：4】顧頭不顧尾

s = ‘python自動化學習‘
#通過切片查找python
s1 = s[0:6]
print(s1)

步長：跳著取

s = ‘python自動化學習‘
#通過跳著切片查找
s2 = s[:5:2] #0可以省略
print(s2)

反方向取值：必須加反向步長-1
s = ‘python自動化學習‘
#倒著取值必須加反向步長 -1
s3 = s[-1:-6:-1]
print(s3)

字符串操作方法：
.capitalize()首字母大寫，其他小寫

s = ‘nxfxxy‘
s1=s.capitalize() #新的字符串,
print(s1)

.upper()全部都大寫

s = ‘nxfxxy‘
s1 = s.upper()
print(s1)

.lower()全部小寫

s = ‘nxfxxy‘
s1 = s.lower()
print(s1)

小練習：
code = ‘QeAr‘.upper().lower()
you = input(‘>>plese:‘).upper().lower()
if you ==code:
print(‘yes‘)
else:
print(‘no‘)

.swapcase()大小寫反轉大變小，小變大

s = ‘nxFxxy‘

.title() 每個首字母大寫，非字符隔開的每個單詞

s = ‘nxFxxy ycq q77*&bai‘
a=s.title()
print(a) #非字母隔開首字母大寫全部

.center（）居中,默認填充為None

s = ‘nxFxxy‘
a =s.center(20,‘&‘)
print(a) #居中，長度自己設定

.startswith（）以什麽開頭

s = ‘nxFxxy‘
a = s.startswith(‘n‘)#以什麽開頭
print(a)

.endswith（）以什麽結尾
s = ‘nxFxxy‘
a = s.endswith(‘y‘)#以什麽結尾

.strip() 去可以寫填充，去除字母、除空格，制表符\t 換行符 非常有用
s = ‘ nxFxxy‘

a = s.strip()
print(a)

.lstrip（）去左邊
.rstrip（）去右邊 #和上面的一樣，不進行舉例

.split() 字符串轉換成列表 重要，設置切割次數

s = ‘sss lll ddd ggg eee‘
sq = s.split()
print(sq) #相當於字符串轉換成列表

.join（）通過連接符連接之前的字符串，也可以對列表進行操作，吧列表轉化為字符串，不能有非字符串的內容如數字
字符串：
s = ‘sfnxFxxy‘
sw = ‘+‘.join(s)
print(sw) # s+f+n+x+F+x+x+y

列表：
ll =[‘xxx‘,‘ddd‘,‘222‘]
l2 = ‘-‘.join(ll)
print(l2) # xxx-ddd-222

.replace（）用於替換

s = ‘sfnxFxxy‘
sq = s.replace(‘xx‘,‘TT‘)
print(sq) # sfnxFTTy

.find () 找字符串的索引如果有多個那就只找一個

s = ‘sfnxFxxy‘
sq = s.find(‘F‘)
print(sq) #4

.index() 如果找不到就報錯不如find好使

s = ‘sfnxFxxy‘
sq = s.index(‘F‘)
print(sq) #4

.isdigit（）用於字符串轉換成數字的判斷是否有

i = ‘123a‘
if i.isdigit():
i = int(i)
else:
print(‘輸入錯誤‘)

.isalpha（）字符組成判斷

i = ‘sdf‘
if i.isalpha():
i = str(i)
print(‘正確‘)
else:
print(‘輸入錯誤‘)

.isalnum（）是否有字符和字母組成判斷
公共方法：
.len（）查看長度

s= ‘sdfsadfasdfasdfadsfadsfdsafewtr‘
sq = len(s)
print(sq) #31

.count（）某個元素出現的次數

s= ‘sdfsadfasdfasdfadsfadsfdsafewtr‘
sq = s.count(‘s‘)
print(sq) #7

格式化輸出：
.format
%s %d 占位符

res = ‘我叫{} 今年{}歲，愛好{}‘.format(‘egon‘,18,‘male‘)
print(res) #我叫egon 今年18歲，愛好male

res = ‘我叫{0} 今年{0}歲，愛好{0}‘.format(‘egon‘,18,‘male‘)
print(res)

res = ‘我叫{name} 今年{age}歲，愛好{hobby}‘.format(name=‘egon‘,age=18,hobby=‘male‘)
print(res)

2、數字 ：int 多用於計算 1 2 3 .。。
i = 3
i = 6
print(i.bit_length())

‘‘‘
二進制 十進制
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
‘‘‘

3、bool ： True False

4、list ： 【】列表，存放各種數據類型容器類型
索引：取出來之後就是字符串

切片 ： 之後的是列表

小練習：

li = [111,‘alex‘,22,‘wusir‘]
print(li[1])
print(li[:4:2])

增刪改查、

增、
.append（）後面加
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.append(‘葫蘆娃‘)
print(l)

insert 插入

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]

l.insert(1,‘天使‘)
print(l)

叠代添加：
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.extend(‘xxxx‘)
print(l)
看效果：[‘lxf‘, ‘sdf‘, ‘pp‘, ‘sdf‘, ‘x‘, ‘x‘, ‘x‘, ‘x‘]

刪除：、

按照索引刪除： pop
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.pop(0)
print(l)

按照元素刪除、 remove
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.remove(‘pp‘)
print(l)

清空列表： clear
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.clear()
print(l)

刪除列表 del
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
del l
print(l)

按照索引刪除：

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
del l[3]
print(l)

按照切片刪除：

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
del l[:3]
print(l)

改：

按照索引改：
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l[0]=‘zookeeper‘
print(l)

按照切片去改：
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘,‘df‘]
l[:2]=‘iopl‘
print(l)

查、:
按照索引查：

按照切片查：

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘,‘df‘]
for i in l:
print(i)

其他方法：
計數count出現的次數
和長度：
l = [1,1,2,3,4,5,76,1,1,6]
print(l.count(1))
print(len(l))

#通過元素找索引
print(l.index(4))

l2 = [3,2,4,5,6,7,8,10,9]
l2.sort()#從小到大
print(l2)
l2.sort(reverse=True) #從大倒小
print(l2)
l2.reverse() #反方向排序
print(l2)

列表的嵌套：

ll = [1, 2, ‘lxf‘, ‘wusir‘,[‘oldboy‘, ‘ycq‘, 99], ‘taibai‘]
ll[2]= ll[2].upper()
print(ll)
ll[4].append(‘女神‘)
print(ll)

5、元祖 ： （）多種數據類型，只讀列表，只限制子集的，孫子的可以改

tu = (1,2,True,[2,3,4],‘alssx‘)
for i in tu:
print(i)

tu = (1,2,True,[2,3,4],‘alssx‘)
#切片、索引
print(tu[2])
print(tu[:4])

6、字典 ：{} 鍵值對key value 大量數據，關聯數據，查詢快，二分查找

key是唯一的，必須是不可變的數據類型：(可hash )： str bool tuple int ：value 是 任意數據類型

數據分類型：
可變： dict list set
容器類型： list tuple dict set
不可變： 不可變的數據類型：(可hash )： str bool tuple int

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘byc‘:[1,2,3]}
print(dic)

增刪改查、

增、
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘high‘] = 180
print(dic)

如果有key在加入有責覆蓋，無責添加
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘name‘] = 180
print(dic)

這個是有責不變，無責添加：
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.setdefault(‘name‘,180)
print(dic)

刪除：、4中方法
通過鍵刪除，相當於list的索引
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.pop(‘name‘)
print(dic)

清空字典：
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.clear()
print(dic)

刪除字典：

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
del dic[‘age‘]
print(dic)

刪除最後一個3.6之後3.5 之前是隨機刪除
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.popitem()
print(dic)

改、

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘name‘]=‘ppp‘
print(dic)

update：

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic) # 將dic所有的鍵值對覆蓋添加（相同的覆蓋，沒有的添加）到dic2中
print(dic2)

查、

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘name‘]
print(dic)
推薦用這個，不報錯
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.get(‘name2‘)
print(dic)

#keys
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
#keys()可以轉化成列表
print(dic.keys())
print(list(dic.keys()))

#values()
print(list(dic.values()))

#.tiems（）
print(list(dic.items()))

for i in dic.items():
print(i)

小練習題：：

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
for k,v in dic.items():
print(k,v)

#len（）查看長度
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
#len
print(len(dic))

#fromkeys
dic1 = dict.fromkeys(‘abc‘,[1,2,3])
print(dic1)

備註：如果要是list當中是空的時候，如果要寫入數據之後，那麽將會給所有都變成寫入的數據不會只有一個有

7、集合 ： 關系型數據的交集/並集/差集/子集。。列表的去重
無序不重復的數據類型，裏面的元素必須是可哈希的，但是集合本身是不可hash

關系測試： 交集、子集、並集、差集
去重（列表去重）

增、
.add
ss = {‘sss‘,‘bbb‘}
ss.add(‘ddd‘)
print(ss)

.update

ss={‘eee‘,‘eee‘,‘ddd‘}
ss.update(‘abc‘)
print(ss)

刪除、

.remove
ss={‘eee‘,‘eee‘,‘ddd‘}
ss.remove(‘ddd‘)
print(ss)

其他集合：
#交集
set1 = {1,2,3,4,5}
set2= {4,5,6,7,8}
print(set1 & set2)

#並集
print(set1 | set2)

#差集
print(set1 - set2 )

反交集

print(set1 ^ set2)

frozenset 不可變集合，讓集合變成不可變的

s = frozenset(‘barry‘)
s1 = frozenset({1,2,3,4})
print(s,type(s))
print(s1,type(s1))

8、數據類型補充

#range 可制定數字列表
for i in range(1,10,2): #有步長
print(i)

註意：
不要改變、列表、字典的大小
如果元祖裏面只有一個元素，並且沒有逗號隔開，那麽他的數據類型與該元素一致
小數據池：int: -5 ~ 256中相同的數全都指向一個內存地址
str: s = ‘a‘* 20 以內都是同一個內存地址，21就不可以了

深淺copy：
對於淺copy來說，第一層創建的是新的內存地址，而從第二層開始，指向的都是同一個內存地址，所以，對於第二層以及更深的層數來說，保持一致性。

對於深copy來說，兩個是完全獨立的，改變任意一個的任何元素（無論多少層），另一個絕對不改變   

9、編碼 ：

電信號01010101010101010
電腦：
a‘siic碼128
7位標識一個字節
升級到8位一個字節256 2的8次方
00000001 ===一個字符
萬國碼啊： unicode包括所有國家
16字節表示一個字符
00000001 00000001 ==一個字符 2的16次方

改變：4個字節表一個字符就是三十二次方
11111111 11111111 11111111 11111111 表示一個字節 2的32次方
資源浪費：

升級utf-8：最少用8位：
英文8位一個字節，00000001
歐洲16位兩個字節，00000001 00000001
亞洲24位三個字節，00000001 00000001 00000001

python3下：
不同編碼之間的二進制是不能互相識別的
pthon3x str 內部編碼方式為unicode（內存）
但是，對於文件的存儲、和傳輸不能用unicode

bytes類型：內部編碼方式（內存）為非unicode
s1 = b‘ffff‘
print(s1,type(s1))

對於中文：

python的數據類型、字符串、列表、字典、元祖、集合、編碼補充等