python的基礎知識點

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

一、運算符
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的基礎知識點”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。