數據
數據類型
數字（整形，長整形，浮點型，復數）
存一個值
有序
不可變
小的數字不會申請內存空間.同值會指向同一地址


詳細類型：int
用途：年齡，級別，等級，身份證號
使用方法:
x=10 #x=int(10)
print(id(x),type(x),x)
詳細類型：float
用途：工資，身高，體重
使用方法:
salary=3.1 #salary=float(3.1)
print(id(salary),type(salary),salary)

字符串(描述性的東西)
存一個值
不可變
用途：名字，性別，地址
使用方法:
name=‘egon‘ #name=str(‘egon‘)
print(id(name),type(name),name)

#優先掌握的操作：
# 按索引取值(正向取+反向取) ：只能取
# print(name[0],type(name[0]))
# print(name[-2])
# name[0]=‘E‘

# 切片(顧頭不顧尾，步長)
# print(name[1:3])
# msg=‘hello world‘
# print(msg[1:7])
# print(msg[1:7:2])

# msg=‘abcdefg‘ #bdf
# # print(msg[1:6:2])
# # print(msg[::2])
# print(msg[6::-1]) #了解

長度len
# msg=‘ab c ‘
# print(len(msg))

成員運算in和not in
# msg=‘hello alex‘
# print(‘a‘ in msg)
# print(‘alex‘ in msg)
# print(‘ae‘ not in msg)

移除空白strip
# password=‘ alex3714 ‘
# password=password.strip()
# print(password)
# print(password.strip())
移除多余指定符號
# msg=‘***egon***********‘
# print(msg.strip(‘*‘))
移除多余指定符號,但是不能移除中間
# msg=‘***eg**on***********‘
# print(msg.strip(‘*‘))

# 切分split
user_info=‘root:x:0:0::/root:/bin/bash‘
按字符
# print(user_info[0:4])
按:號分割
# print(user_info.split(‘:‘)[0])
只分割一次
# print(user_info.split(‘:‘,1))

默認按空格分
# cmd=‘put a.txt‘
# print(cmd.split())

# filepath=‘put /a/b/c/d/a.txt‘
# print(filepath.split())

按空格分.只分割一次,只打印第一個
# msg=‘alex say i have on tesla‘
# print(msg.split(maxsplit=1)[0])

#isdigit:用來判斷字符是否是由純數字組成（bytes，unicode）

# 循環

#常用操作

清楚左右兩邊多余符號
# msg=‘***alex****‘
# print(msg.strip(‘*‘))
# print(msg.lstrip(‘*‘))
# print(msg.rstrip(‘*‘))

以什麽開頭/結尾
# msg=‘alex_SB‘
# print(msg.startswith(‘alex‘))
# print(msg.endswith(‘SB‘))

替換字符
# msg=‘alex say i have one telsa, my name is alex‘
# print(msg.replace(‘alex‘,‘SB‘,1))

格式化輸出
# print(‘my name is %s my age is %s‘ %(‘egon‘,18))
# print(‘my name is {} my age is {}‘.format(‘egon‘,18))
# print(‘{1} {0} {1}‘.format(‘egon‘,18))
# print(‘my name is {x} my age is {y}‘.format(y=18,x=‘egon‘))

split
將指定符號作為分割符號
# user_info=‘root:x:0:0::asdfasdf‘
# l=user_info.split(‘:‘)

join
將一段分開的字符拼接在一起
# print(‘:‘.join(l))
# print(‘‘.join(l))
# print(‘ ‘.join(l))

#center,ljust,rjust,zerofill
將單詞放在中間,左填充,右填充,使用0填充
#=================egon===================
# print(‘egon‘.center(30,‘=‘))
# print(‘egon‘.rjust(30,‘=‘))
# print(‘egon‘.ljust(30,‘=‘))
# print(‘egon‘.zfill(30))

#了解部分
#find,rfind,index,rindex,count
(要找的內容,從第幾個開始,到第幾個結束)
# msg=‘hello world‘
# print(msg.find(‘ell‘))#從左到右找，如果有，則返回第一個字符的索引
# print(msg.find(‘easdfasdf‘))#從左到右找，如果沒有，返回-1

# print(msg.index(‘d‘,0,3))#從左到右找，如果有，則返回第一個字符的索引
# print(msg.index(‘x‘))#從左到右找，如果有，則返回第一個字符的索引,如果沒有找到就會報錯

#找到指定內容技術
# print(msg.count(‘l‘,0,4))
# print(msg.count(‘l‘,0,3))

# 控制幾個制表符
# msg=‘abc\tdeft‘
# print(msg.expandtabs(3))

# msg=‘alex Say hello‘
句首大寫
# print(msg.capitalize())
全部大寫
# print(msg.upper())
全部小寫
# print(msg.lower())
每個單詞首字母大寫
# print(msg.title())
大小寫翻轉
# print(msg.swapcase())

is系列
# msg=‘Alex Say Hello‘
是否大寫
# print(msg.isupper())
是否小寫
# print(msg.islower())
是否首字母大寫
# print(msg.istitle())

# msg=‘asasdf123‘
是否由字母或數字組成
# print(msg.isalnum())

msg=‘asdfasdf‘
是否純字母
print(msg.isalpha())

#
# msg=‘ 1‘
是否全部空格
# print(msg.isspace())
# msg=‘aaaai fabc‘
是否包含python關鍵字
# print(msg.isidentifier())

#判斷數字
# age=10
# inp=input(‘>>: ‘).strip()
# if inp.isdigit():
# inp=int(inp)
# if inp > age:
# print(‘ok‘)
#
# else:
# print(‘必須輸入數字‘)

num1=b‘4‘ #bytes
num2=u‘4‘ #unicode,python3中無需加u就是unicode
num3=‘四‘ #中文數字
num4=‘壹‘ #大寫數字
num5=‘Ⅳ‘ #羅馬數字

#bytes,unicode*******
# print(num1.isdigit())
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())
# print(num5.isdigit())

#unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())
# print(num5.isdecimal())

#unicode,漢字，羅馬
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())
# print(num5.isnumeric())

列表
#作用：多個裝備，多個愛好，多門課程，多個女朋友等

#類型可變

#定義：[]內可以有多個任意類型的值，逗號分隔
my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5] #本質my_girl_friends=list([...])

優先掌握的操作：
按索引存取值(正向存取+反向存取)：即可存也可以取
# print(my_girl_friends[2])
# print(my_girl_friends[-1])
# print(id(my_girl_friends))
# my_girl_friends[0]=‘SB‘
# print(id(my_girl_friends))
# print(my_girl_friends)

切片(顧頭不顧尾，步長)
# print(my_girl_friends[0:2])
# print(my_girl_friends[0:4:2])

長度
# print(len(my_girl_friends))

成員運算in和not in
# print(‘alex‘ in my_girl_friends)
# print(5 in my_girl_friends)

追加
# my_girl_friends.append(‘6號‘)
# print(my_girl_friends)

刪除
# del my_girl_friends[2]
# print(my_girl_friends)

# print(my_girl_friends.remove(‘yuanhao‘)) #remove是單純的刪除，不會返回刪除的值，並且是按照值去刪
# res=my_girl_friends.pop(1) #按照索引取刪，默認從末尾開始刪
# print(res)

# my_girl_friends.pop() #按照索引取刪，默認從末尾開始刪

# print(my_girl_friends)

# 循環

#常用操作：

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘alex‘,‘yuanhao‘,4,5] #本質my_girl_friends=list([...])

插入
# my_girl_friends.insert(0,‘sb_alex‘)
# my_girl_friends.insert(2,‘yh‘)

插入多個.從末尾開始
# my_girl_friends.extend([1,2,3,4])

計算列表中有幾個指定的值
# print(my_girl_friends.count(‘alex‘))
# print(my_girl_friends)

了解
清空列表
# my_girl_friends.clear()
# print(my_girl_friends)
復制一個新列表
# l=my_girl_friends.copy()
# print(l)

反轉整個列表順序
# my_girl_friends.reverse()
# print(my_girl_friends)

排序
# l=[3,4,-1,2]
# reverse=True #默認從小到大.這個參數從大到小
# l.sort(reverse=True)
# print(l)

#練習：
#隊列：先進先出
#append，pop
# l1=[]
# l1.append(‘first‘)
# l1.append(‘second‘)
# l1.append(‘third‘)
#
# print(l1.pop(0))
# print(l1.pop(0))
# print(l1.pop(0))

#堆棧：先進後出

# l1=[]
# l1.append(‘first‘)
# l1.append(‘second‘)
# l1.append(‘third‘)
#
# print(l1.pop())
# print(l1.pop())
# print(l1.pop())

元組
#作用：存多個值，對比列表來說，元組不可變（是可以當做字典的key的），主要是用來讀
#可以存多個值
#不可變類型
#定義方式：
ages=(10,12,18,33,18) #ages=tuple((10,12,18,33))
# print(id(ages),type(ages),ages)

#優先掌握的操作：
# 按索引取值(正向取+反向取)：只能取
# 切片(顧頭不顧尾，步長)
# print(ages[0:2])
# print(ages)

# 長度
# print(len(ages))
# # 成員運算in和not in
# print(10 in ages)

#其他操作：
# print(ages.index(18))
# print(ages.index(123123123123))

# print(ages.count(18))

根據索引打印值
# l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# # l=‘abcde‘
# l=(‘a‘,‘b‘,‘c‘,‘d‘,‘e‘)
# index=0
# while index < len(l):
# print(l[index])
# index+=1

# l1=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# for item in l1:
# print(item)
# l2=‘abcde‘
# for item in l2:
# print(item)
# l=(‘a‘,‘b‘,‘c‘,‘d‘,‘e‘)

# for i in range(1,10,2):
# print(i)
# l1=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# for i in range(len(l1)):
# print(i,l1[i])

# msg_dic={
# ‘apple‘:10,
# ‘tesla‘:100000,
# ‘mac‘:3000,
# ‘lenovo‘:30000,
# ‘chicken‘:10,
# }
#
# goods_l=[]
# while True:
# for key in msg_dic:
# print(key, msg_dic[key])
# choice = input(‘商品名>>: ‘).strip()
# if choice not in msg_dic:continue
# count = input(‘個數>>: ‘).strip()
# if count.isdigit():
# goods_l.append((choice,msg_dic[choice],int(count)))
# print(goods_l)

#while+else
# for i in range(5):
# if i == 3:break
# print(i)
# else:
# print(‘ok‘)

字典
作用：存多個值,key-value存取，取值速度快
存多個值
不可變類型
定義：key必須是不可變類型，value可以是任意類型

# d={‘a‘:1}
# d={0:1}
# d={[1,2,3]:1} #列表不能當做字典的key
# d={(0,‘mac‘):3000}
#
# print(d[(0,‘mac‘)])

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘} #本質info=dict({....})

優先掌握的操作：
按key存取值：可存可取
# print(info[‘sex‘])
# info[‘hobbies‘]=[‘read‘,‘music‘,‘play‘,‘sleep‘,‘eat‘]
# print(info)

長度len
# print(len(info))

成員運算in和not in

刪除
# print(info.pop(‘name‘))
# print(info.pop(‘name1213‘,‘確實是沒有的，我的哥‘))
# print(info.pop(‘name1213‘,None))

鍵keys()，值values()，鍵值對items()
# print(info.keys())
# print(info.values())
# print(info.items())

# for key in info.keys():
# print(key)

# for val in info.values():
# print(val)

# for item in info.items():
# print(item[0],item[1])

循環

常用方法
# info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}
# print(info[‘name123‘])
# print(info.get(‘name123‘,123))
# print(info.popitem())
#
#
# for k,v in info.items(): #k,v=(‘name‘, ‘egon‘)
# print(k,v)

# print(info.setdefault(‘hobbies‘,[‘read‘,‘music‘])) #有則不改，返回已經有的值，沒有則新增，返回新增的值
# print(info)

# print(id(info.setdefault(‘hobbies‘,[])))
# print(id(info[‘hobbies‘]))
l=[]

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘,}
# if ‘hobbies‘ not in info:
# info[‘hobbies‘]=[]
# info[‘hobbies‘].append(‘music‘)
# else:
# info[‘hobbies‘].append(‘read‘)
#
# if ‘hobbies‘ not in info:
# info[‘hobbies‘] = []
# info[‘hobbies‘].append(‘music‘)
# else:
# info[‘hobbies‘].append(‘read‘)
#
# print(info)

# info.setdefault(‘hobbies‘,[]).append(‘music‘)
#
# # {‘name‘: ‘egon‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘hobbies‘: [‘music‘, ]}
# info.setdefault(‘hobbies‘,[]).append(‘read‘) #[‘music‘, ].append(‘read‘)
# print(info)

了解
# info_new={‘a‘:1,‘age‘:19}
# info.update(info_new)
# print(info)

# dic={‘name‘:None,‘age‘:None,‘sex‘:None,‘hobbies‘:None}
# dic1={}.fromkeys([‘name‘,‘age‘,‘hobbies‘],None)
# print(dic1)

補充兩種賦值方式：
#一：鏈式賦值
# x=10
# y=x
# x=y=z=10
# print(id(x),id(y),id(z))

交換兩個變量的值
# m=10
# n=20
# temp=n
# n=m #n=10
# m=temp
# print(m,n)
# m,n=n,m
# print(m,n)

從一個數據類型中解壓出我們想要的值
# t=(10.3,11.2,12.1,14.3,3.1)

# x,y,z,a,b=t
# print(x,y,z,a,b)

# x,_,_,_,b=t
# print(x,b)
# print(_)

# x,*_,b=t
# print(x,b)

# x,*_=‘hello‘
# print(x)

# x,y,z={‘a‘:1,‘b‘:2,‘c‘:3}
# print(x,y,z)


集合
作用：去重，關系運算，
存多個值

# pythons=[‘alex‘,‘wupeiqi‘,‘egon‘,‘yuanhao‘,‘gangdan‘,‘oldboy‘]
# linuxs=[‘egon‘,‘oldboy‘,‘tiedan‘,‘liudan‘]
#
# l=[]
# for item in pythons:
# if item in linuxs:
# l.append(item)
# print(l)

定義：
# 1：每個元素必須是不可變類型(可hash，可作為字典的key)
# 2:沒有重復的元素
# 3：無序
# s={1,2,‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘} #s=set({1,2,‘a‘})

# print(type(s),s)

# 優先掌握的操作：
# 長度len
# s={1,2,‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘}
# print(len(s))
# 成員運算in和not in
# print(‘a‘ in s)
# for item in s:
# print(item)

# | 並集
# s1={1,2,3}
# s2={3,4,5}
# print(s1 | s2)

# & 交集
# print(s1 & s2)

# -差集
# print(s1 - s2)
# print(s2 - s1)

# ^ 對稱差集
# s1={1,2,3}
# s2={3,4,5}

# ==
# > ， >= ， <, <= 父集，子集
# s1={1,2,3,4}
# s2={3,4,5}
# print(len(s1) > len(s2))

# s1={1,2,3,4}
# s2={3,4}
# print(s1 > s2)
# print(s1 >= s2)

練習：
# pythons={‘alex‘,‘egon‘,‘yuanhao‘,‘wupeiqi‘,‘gangdan‘,‘biubiu‘}
#
# linuxs={‘wupeiqi‘,‘oldboy‘,‘gangdan‘}
#
# # 　1. 求出即報名python又報名linux課程的學員名字集合
# print(pythons & linuxs)
# # 　　2. 求出所有報名的學生名字集合
# print(pythons | linuxs)
# # 　　3. 求出只報名python課程的學員名字
# print(pythons - linuxs)
# # 　　4. 求出沒有同時這兩門課程的學員名字集合
# print(pythons ^ linuxs)

#常用操作
s1={1,2,3,‘a‘,4}
# print(s1.pop()) #隨機刪，並返回刪除的結果

# s1.remove(‘a‘) #單純地刪，不會返回刪除的結果，並且如果刪除的元素不存在則報錯
# s1.remove(‘asdfasdfa‘) #單純地刪，不會返回刪除的結果
# print(s1)
# print(s1.discard(‘a‘)) #單純地刪，不會返回刪除的結果，並且如果刪除的元素不存在返回None，不會報錯
# print(s1)

# s1.add(‘b‘)
# print(s1)

s1={1,2,3}
s2={4,5}
# print(s1.isdisjoint(s2)) #如果s1和s2沒有交集則返回True

了解
# s1={1,2,3,4}
# s2={3,4,5}

| 並集
# print(s1.union(s2))

& 交集
# print(s1.intersection(s2))
# s1.intersection_update(s2) #s1=s1.intersection(s2)
# print(s1)

-差集
# print(s1.difference(s2))

^ 對稱差集
# print(s1.symmetric_difference(s2))

==
# > ， >= ， <, <= 父集，子集
# s1={1,2,3,4}
# s2={3,4}
# print(s1.issuperset(s2))
# print(s2.issubset(s1))

去重
# l=[‘a‘,‘b‘,1,‘a‘,‘a‘]
# print(list(set(l)))

# l=[‘a‘,‘b‘,1,‘a‘,‘a‘]
# l_new=list()
# s=set()
# for item in l:
# if item not in s:
# s.add(item)
# l_new.append(item)
l=[
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:20,‘sex‘:‘female‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
]
l_new=list()
s=set()
for item in l:
res = (item[‘name‘], item[‘age‘], item[‘sex‘])
if res not in s:
s.add(res)
l_new.append(item)

print(l_new)

了解：不可變集合
fset=frozenset({1,2,3})
fset.

數據類型、字符編碼、文件處理