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