python的基礎知識點

165次閱讀

共計 3191 個字符，預計需要花費 8 分鐘才能閱讀完成。

這篇文章將為大家詳細講解有關 python 的基礎知識點，丸趣 TV 小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

一、運算符
in
“hello”in“asdfashellosdfadfadfa”
li in [li , ok]
二、基本數據類型
int
a、創建方式
n1 = 123 #根據 int 類，創建了一個對象
n2 = int123 # 根據 int 類，創建了一個對象
特有的功能在：
int 類
功能 1
功能 1
功能 1
…
__init__ 初始化
b、int 內部優化
n1 = 123
n2 = n1

n1 = 123
n2 = 123
===== 兩份內存 =====
-5~257 這個可以通過修改源碼改變，由 c 語言演變過來的，查源碼
n1 = 123
n2 = 123

n1 = 123
n2 = 123
==》對象的內存地址 =id（對象或對象的變量名）這樣可以查看內存地址
c、長度限制
用 int，超出了范圍（根據計算機的不同定義的）
32 位的操作系統 -2**31 ~ 2**31-1
64 位的操作系統 -2**63 ~ 2**63-1
long
bytes：可以將字符轉換成字節

str
a、創建方式
s1 = zq
s1 = str(zq)
b、特有的功能
# 兩端去除空格
#s1.strip（）

# 以 … 開頭
#s1.startwith（）

# 找子序列
#s1.find（）

# 將字符串中的某子序列替換成指定的值
#s1.replace（）

# 變大寫
#s1.upper（）

# 是 … 嗎？
#s1.isalpha（）
c、公共功能
索引：只能取一個元素
切片：取多個元素
len：
for：

編碼、for：
name = 李露
for i in name:
print (i)
bytes_list = bytes(i, encoding= utf-8)
print(bytes_list)
for b in bytes_list:
# 字節默認 16 進制
# 輸出每一個字節默認 16 進制
print(b,bin(b))
1、3.6 版本中 for 循環時候，循環的每一個元素是“字符”
2、字符 =》字節
bytes_list = bytes（“字符串”，encoding=‘utf-8’）
#utf-8 -》3 字節
#gbk -》2 字節
print（bytes_list）# 默認每一個字節都是 16 進制
for b in bytes_list：
print（b） # 默認每一個字節都是 10 進制
3、10 進制的數字 ==》 2 進制
len
id
bin（10 進制的數字）
d、bytes 和 str 的轉換
a = 張強
# 將字符串轉換成字節
b1 = bytes(a, encoding= utf-8)
print(b1)
b2 = bytes(a,encoding= gbk)
print(b2)
# 將字節轉換成字符串
print(str(b1,encoding= utf-8))
print(str(b2,encoding= gbk))

#########
x = str()
# 創建字符串
# 轉換成字符串
o = bytes()
# 創建字節
# 轉換成字節，字符串，要編程什么編碼類型的字節

str()
str 類__init__
list
a、創建和轉換
1、創建
可變的元素的“集合”，列表
li = [11,22,33,44]
li = list()
————
str – 創建字符串，或者將其他的轉換成字符串
list – 創建列表，將其他元素轉換成列表
li = ([11,22,33,44])
2、轉換
#iterable 可迭代的：for 可以循環的
a1 = 張強
#for，字符 == iterable
li = list(a1) #for 循環，將循環的每一個元素，當做列表的元素
print(li)

######### 字典 #######
dic = {k1 : zq , k2 : sdfsdf}# 注意是大括號
l3 = list(dic)
print(l3)
l4 = list(dic.values())
print(l4)
l5 = list(dic.items())
print(l5)

# 字符串，元組，字典 =》列表
b、列表特有功能
li = [11,22,3]
# 追加
# li.append()
# 清楚
#li.clear（）
# 擴展自己，用另外一個可迭代的對象擴充到自己
#str 字符串，列表 list，字典 dic，元組 tuple
# z = 張強
# li.extend(z)
# print(li)
# 翻轉，自己內部元素翻轉
#li.reverse()
# 向指定位置插入指定元素
# li.insert(1, x)
# print(li)
c、公共功能
li = [zq , fd , gg , rg]
索引：只能取一個元素
切片：取多個元素
li = [sdf , sdfe , hdf , sdgx]
print(li[1])
print(li[1:3])
sdfe # 索引
[sdfe , hdf] #切片本來是什么類型，切片取出來的就是什么類型

for
len

d、多層嵌套
li = [sdf , dff , we , gr]
li = [zq ,12,{ k1 : b1 , b2 :{ qq :(11,22,33), ii :741}}]

li[2] — {k1 : b1 , b2 :{ qq :(11,22,33), ii :741}}
li[2][k2] == {qq :(11,22,33), ii :741}
li[2][k2][qq] — {11,22,33}
元組 tuple
a、創建和轉換
t = (11,22,33)
t = tuple((11,22,33))
t = tuple{[]} #字符串、列表、字典
b、特有的方法
count index
c、嵌套（元素不可修改）
t = (11,22,33)
t = (11,22,[ zq ,{ zq1 : z1}])
t[2] = [zq ,{ zq1 : z1}]
t[2][1] = {zq1 : z1}
t[2][1][zq1]
e、元組的特性，不可修改，誰不可修改 — 元組的元素不可修改，元素的元素可以修改
# 給字典里面的元素添加新元素，兩種方法
dic = {zq1 : zz}
# dic.update({zq2 :15}) #新添加的元素注意加大括號
# print(dic)
dic[zq2] = 15
print(dic)

# t = (11,22,33)
t = (11,22,[ zq ,{ zq1 : z1}])
# print(t[2])
# print(t[2][1])
# print(t[2][1][zq1])
# print(t)
# t[2].append(zz)
# print(t)

t = (11,22,[ zq ,{ zq1 : z1}])
t[2][1][zq2]=15
print(t)
t[2][1].update({zq3 :15})
print(t)
# 什么時候是自身的變化什么時候產生新的
# 一般對于字符串的操作
一般字符串，執行一個功能，生成一個新內容，原來內容不變
list、tuple、dic，執行一個功能，自身進行變化

字典：
1. 創建
a = {z1 :8}
a = dict()
li = [11,22,33]
# new_dict = dict(li) #這是不可以的
# new_dict = dict(enumerate(li,10))
new_dict = dict(enumerate(li,1))
print(new_dict)
# 想要把列表轉換過來，只能用 enumerate
2. 字典的內部功能
dic = {k1 :123, k2 :456, k3 :566}
# 方法，無 @staticmothod，對象. 方法
# dic.get()
#k1,k2, 默認值 123

# 方法，有 @staticmothod，類. 方法
# n = dic.fromkeys([k1 , k2 , k3], 123 )
#fromkeys 的功能就是尋找到字典里面存在的 key 值，重新給其重新賦值
# n = dict.fromkeys([k1 , k2 , k3], 123 )
# print(n)
n = dict.fromkeys([k1 , k2 , k3],[])
print(n)
n[k1].append(x)
print(n)

關于“python 的基礎知識點”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。

正文完