python的基础知识点

共计 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 的基础知识点”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。