數據類型

第三章 基礎

3.1編碼初識

ascii 256字母沒有中文

一個字節 8位

gbk 中國

中文2字節 16位

英文1字節8位

unicode 萬國碼

前期 2字節 8位

後期變成4個字節 32位

utf-8 可變編碼 英文1 歐洲2 亞洲3字符

3.2格式化輸出

根據數據交互輸出的數據進行交互佔位

舉例：%s %d %

%s
#%是佔位符%s格式化輸出字符串
name=input('name')
sex=input('sex')
money=input('moeny')#工資
print(name,sex,money) #直接輸出

怎樣進行格式化輸出呢

print(('%s,%S,%S')%(name,sex,money))

%d

print(('%s,%S,%d')%(name,sex,money))

若是使用input進行格式化輸出默認 字符串須要強行轉換 若是不轉換直接輸出就會出現錯誤

%d輸入一個整數（整型）

碼雲

Git 全局設置:

git config --global user.name "Strawbarry"
git config --global user.email "strawbarry@user.noreply.gitee.com"

建立 git 倉庫:

mkdir 19062824029
cd 19062824029
git init#建立一個本地倉庫
touch README.md
git add README.md 添加到緩存區
git commit -m "first commit" 提交
git remote add origin https://gitee.com/strawbarry/19062824029.git
git push -u origin master

若是密碼輸入錯誤

3.3基礎數據類型擴展

一 整型（int）

python 全部的整型都是用於計算和比較的，

二進制和十進制 轉換十六進制

1111  
8421   
15=F= 1111
14=E=1110
13=D=1011
12=C=1100
11=B=1011
10=A=1010

進制之間轉換 python

二進制轉十進制
print(int("1111",2));
#15
print(int("6f",16));
#111
print(int("157",8))
#111
十進制轉二進制
bin（）二進制轉換
bin(10);
format(10,"08b")#十進制轉8位二進制
十進制轉八進制
oct八進制轉換
v_code=15
x=oct(v_code)
x=format(v_code, '#o')  # '0o17'，  
等效於：x=oct(v_code)
y=format(v_code, 'o')   # '17'
十進制轉16進制
hex（）16轉換
v_code=15
x=format(v_code, '#x')  # '0xf'，   
等效於：x=hex(v_code)
y=format(v_code, 'x')   # 'f'
z=format(v_code, '#X')   # 'OXF'
z=format(v_code, 'X')   # 'F'

十六進制 123456789ABCDEF

二進制轉8進制 三位一轉

16進制 八進制

互轉須要以先轉換二進制方便轉換

3.3.1bool str int 強制轉換

int ---> bool

i = 100
print(bool(i))  # True  # 非零即True
i1 = 0
print(bool(i1))  # False 零即False

bool ---> int

t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0

int ---> str
i1 = 100
print(str(i1))  # '100'

# str ---> int  # 所有由數字組成的字符串才能夠轉化成數字
s1 = '90'
print(int(s1))  # 90

# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'

3.3.2str（字符串）

索引

索引就是下標 組成的元素是從0開始爲第一個起始點

a = 'ABCDEFGHIJK'
print(a[0])#打印出A
print(a[3])#打印出D
print(a[5])#打印出F
print(a[7])#打印出H

切片

首先在列表中有一個規則就是顧頭不顧尾

什麼叫顧頭不顧尾 顧名思義就是

a = 'ABCDEFGHIJK'

print[0:4]#輸出ABC     顧頭不顧腚（尾）

a = 'ABCDEFGHIJK'
print(a[0:3])  # print(a[:3]) 從開頭開始取0能夠默認不寫
print(a[2:5])
print(a[:]) #默認到最後
print(a[:-1]) # -1 是列表中最後一個元素的索引，可是要知足顧頭不顧腚的原則，因此取不到K元素
print(a[:5:2]) #加步長
print(a[-1:-5:-2]) #反向加步長

步長

a = 'ABCDEFGHIJK'

print[-3:-2:-3]

一.數據補充

咱們前期的時候和你們說了,有些方法咱們放在數據類型補充的這一天中,咱們今天將前面沒有講解的內容,都一塊兒講解了,就先從str開始

str:

以什麼開頭:

\# s = "ALEX" 

\# s1 = s.startswith("E",2,6) 

\# print(s1)

以什麼結尾:

\# s = "ALEX" 

\# s1 = s.endswith("X",3,4) 

\# print(s1)

統計

\# s = "alexdxjbx" 

\# s1 = s.count("x") 

\# print(s1)

1.1 首字母大寫

name = "meet"
name.capitalize()

1.2 每一個單詞的首字母大寫

name = "meet"
name.title()

1.3 大小寫反轉

name = "meet"
name.swapcase()

1.4 統計

name = "meet"
name.count()

1.5 查找

name = "meet"
name.find()  # 當查找的時候數據不存在返回-1

name = "meet"
name.index() # 當查找的時候數據不存在報錯

1.6 居中

name = "meet"
name.center(20) # 居中一共佔用20個位置

1.7 填充

name = "meet{},{},{}"
name1 = name.format("郭寶元","寶帥","寶哥")  # 按照位置順序填充
print(name1)

name = "meet{0},{1},{2}"
name2 = name.format("寶帥","寶哥","郭寶元")  # 按照下標填充
print(name2)

name = "meet{a},{c},{b}"
name3 = name.format(a="郭寶元",b="寶帥",c="寶哥") # 按照關鍵字填充
print(name3)

1.8 拼接 將可迭代容器轉換成字符串 字典拼接的是鍵

可迭代容器中的元素必須是字符串類型

lst = ["2","3","4","5"]
print('*'.join(lst))

tu = ("2","3","4","5")
print('*'.join(tu))

dic = {"key1":2,"key2":4}
print('*'.join(dic))

se = {"1","3","34"}
print('*'.join(se))

字符+

name1 = "alex"
name2 = "wusir"
print(id(name1))
print(id(name2))
print(id(name1 + name2))

字符*

name1 = "alex"
print(id(name1))
print(id(name1 * 5))

字符 + 和 * 都是開闢新的空間

\# print(s.isalnum()) # 判斷是否是字母,數字,中文 

\# print(s.isalpha())  # 判斷是否是字母,中文 

\# print(s.isdigit())  # 判斷字符串是否是全都是阿拉伯數字 

\# print(s.isdecimal())  # 判斷是不是十進制

list:

1.1 反轉

lst = [1,2,3,4,5]
lst.reverse()

1.2 排序

lst = [1,2,3,4,5]
lst.sort()  # 升序
lst.sort(reverse=True)  # 降序

1.3 查找

lst = [1,2,3,4,5]
lst.index(3) # 存在就返回索引,不存在就報錯

1.4 統計

lst = [1,23,4,5,6,]
lst.count(23) # 統計23出現的次數

list +

lis = [1,2,3]
lst1 = [4,5,6]
print(id(lis))
print(id(lst1))
print(id(lis + lst1))

list *

lst = [1,2,3]
print(lst * 5)
print(id(lst))
print(id(lst * 5))

面試題:

lst = [[]]
new_lst = lst * 5
new_lst[0].append(1)
print(new_lst)
'''
[[1][1][1][1][1]]
'''

列表在進行乘法的時候元素都是共用

tuple:

面試題:

tu = (1)  # 獲取的括號中元素的自己
tu = (1,2)# 獲取的是元組
tu = (1,) # 獲取的是元組

列表可以支持+, 元組也能夠支持+,

+

tu = (1,2)
tu1 = (3,4)
tu2 = tu + tu1
print(id(tu))
print(id(tu1))
print(id(tu2))

*

tu = ([],)
tu1 = tu * 5
tu1[0].append(9)
print(tu1)

列表在進行乘法的時候元素都是共用

tu = (1,2)
tu1 = tu * 5
print(tu1)
print(id(tu1[0]),id(tu1[-2]))

dict:

[python---建立字典的方式]

• [一、用{}建立字典]
• [二、用內置函數dict()]
• [1)、入參爲相似a="1"的鍵值對]
• [2)、入參爲一個元組，元組內部是一系列包含兩個值的元組，例如(("a", "1"), ("b", "2"))]
• [3)、入參爲一個元組，元組內部是一系列包含兩個值的列表，例如(["a", "1"], ["b", "2"])]
• [4)、入參爲一個列表，列表內部是一系列包含兩個值的元組，例如[("a", "1"),("b", "2")]]
• [5)、入參爲一個列表，列表內部是一系列包含兩個值的列表，例如[["a", "1"],["b", "2"]]]
• [三、用戶fromkeys方法建立字典，第一個]

一、用{}建立字典

代碼：

x ={"a":"1", "b":"2"}
print（x）

輸出：

{'a': '1', 'b': '2'}

二、用內置函數dict()

1)、入參爲相似a="1"的鍵值對

代碼：

x =dict(a="1", b="2")
print (x)

輸出：

{'a': '1', 'b': '2'}

2)、入參爲一個元組，元組內部是一系列包含兩個值的元組，例如(("a", "1"), ("b", "2"))

代碼：

x=dict((("a","1"), ("b","2")))
print (x)

輸出

{'a': '1', 'b': '2'}

3)、入參爲一個元組，元組內部是一系列包含兩個值的列表，例如(["a", "1"], ["b", "2"])

代碼：

?

x=dict((["a", "1"], ["b", "2"]))
printx

輸出：

{'a': '1', 'b': '2'}

4)、入參爲一個列表，列表內部是一系列包含兩個值的元組，例如[("a", "1"),("b", "2")]

代碼：

x=dict([("a", "1"),("b", "2")])
print x

輸出：

{'a': '1', 'b': '2'}

5)、入參爲一個列表，列表內部是一系列包含兩個值的列表，例如[["a", "1"],["b", "2"]]

代碼：

x =dict([["a", "1"],["b", "2"]])
print x

輸出：

{'a': '1', 'b': '2'}

注意：

• 對於a="1"的方式初始化字典，字典的key只能爲字符串，而且字符串不用加引號
• 對於dict內置函數初始化當入參是一個元組時，例如1)、2)，元組內部的兩元素元組或者列表至少爲兩個，不然會出錯

三、用戶fromkeys方法建立字典，第一個

代碼：

dict.fromkeys(("a","b"),1)
print (x)

輸出：

{'a': 1, 'b': 1}

入參能夠的第一個參數是一個列表或者元組，裏邊的值爲key，第二個參數是全部key的value值

字典定義方式:

dict(key=1,key1=2,key2=3)

1.1 隨機刪除

dic = {"key":"value","key2":"value2"}
dic.popitem()  # 隨機刪除

此處說明一下,官方文檔中表示是隨機刪除一個鍵值對中,可是咱們實際測試的時候

都是刪除字典中最後的一個鍵值對,這也是一個Python36中目前存在的一個bug

1.2 批量建立字典

dic = {}
dic1 = dic.fromkeys("abc",[1,2])
print(dic1)

formkeys這個是個坑,坑點就在於值是可變數據類型的時候,當第一個鍵對應的值進行修改了之後,其他的鍵對應的值也都跟着進行改變了. 如何避免坑,就是批量建立字典的時候值不能使用可變的數據類型.

set:

集合定義方式:

set("12345")
{1,2,3,4,5} # 將字符串進行迭代添加

最後咱們對咱們學習的這些數據類型進行一個總結,咱們按照有序,無序,可變,不可變,取值方式來總結

• 有序:
  • 數字
  • 字符串
  • 列表
  • 元組
• 無序:
  • 字典
  • 集合
• 可變數據類型:
  • 列表
  • 字典
  • 集合
• 不可變數據類型:
  • 字符串
  • 數字
  • 元組
• 取值順序:
  • 直接取值 — 數字,布爾值,集合
  • 順序取值(索引) — 列表,元組,字符串
  • 經過鍵取值 — 字典

類型轉換

元組 => 列表   list(tuple)
列表 => 元組   tuple(list)
列表 => 字符串 ''.join(list)#不能整數 必須是字符串類型的str（）
字符串 => 列表 str.split

轉換成False的數據:
0,'',None,[],(),{},set() 都是False

find找不到返回-1

index找不到報錯 找到返回索引

is系列

isdigit

isdecimal

isalnum#判斷是否是 字母 數字漢字

isalpha

公共方法

len()

列表list

列表是一個可迭代對象

用法：你須要存儲大量的數據，且須要這些數據有序的時候。制定一些特殊的數據羣體：按順序，按規則，自定製設計數據

增

1.append直接添加#追加(在列表的最後位置添加一個內容)

2.expend迭代添加

3.lst.insert(2,"wusir")  #插入  之後儘可能不要使用(當數據量比較大的時候會影響效率

刪

del

remove

clear

改

索引，切片進行修改

lst = ["太白", "太黑", "五色", "銀王", "⽇天"] 
lst[1] = "太污"   # 把1號元素修改爲太污 print(lst) 
lst[1:4:3] = ["麻花藤", "哇靠"]     # 切片修改也OK. 若是步長不是1, 要注意元素的數 
print(lst) 
lst[1:4] = ["我是哪一個村的村長王富貴"]  # 若是切片沒有步長或者步長是1. 則不用關心個數 
print(lst)

a=list(1,3,4)

print(a)

查

索引查詢

列表是一個可迭代對象，能夠進行for循環

列表的嵌套

lst = [1,'太白','wusir',['麻花疼',['可口可樂'],'王健林']]

3.2.4列表的方法

len

index 返回索引 找不到報錯

sort排序

reverse反轉

4.元組tuple

是不可變類型

是一個特殊的列表不能增長不能刪除只能查看

元組的方法

長度len()

len()

三.其餘（for，enumerate，range）。
for循環：用戶按照順序循環可迭代對象的內容。

msg = '老男孩python是全國範圍內最好的python培訓機構'
for item in msg:
print(item)

li = ['alex','銀角','女神','egon','太白']
for i in li:
print(i)

dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
print(k,v)

enumerate：枚舉，對於一個可迭代的（iterable）/可遍歷的對象（如列表、字符串），enumerate將其組成一個索引序列，利用它能夠同時得到索引和值。

li = ['alex','銀角','女神','egon','太白']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默認是0，可更改
print(index, name)　　　　

range：指定範圍，生成指定數字。

for i in range(1,10):
print(i)

for i in range(1,10,2): # 步長
print(i)

for i in range(10,1,-2): # 反向步長
print(i)

l1 = ['wusir', 'alex', '太白', '女神', 12, 666] for i in range(len(l1)): print(i)