从入门到自闭之python初识
Day 01
整型:
对比:
- 在python 2 版本中有整型,长整型long
- 在python 3 版本中全部都是整型
用于计算和比较
整型和布尔值的转换
二进制转换成十进制:
print (int("111010100",2))
python
2进制 - 10进制
0 * 20 + 1 * 2 ** 1 + 1 * 22 + 1* 2**3 + 1 * 2 ** 4 + 1 * 2 ** 5
0 + 2 + 4 + 8 + 16 + 32 = 62
print(int("111110",2))
十进制转换成二进制:
print(bin(30))
python
10进制 - 2进制
30 0
15 1
7 1
3 1
1 1
11110
print(bin(30))
整型中只要是非零的就是True
在布尔值中:1--True,0--False
在字符串中的内容非空就是True
int,str,bool
a = bool(0)
print(a) a = int(True)
print(a) a = int(False)
print(a) a = bool("a")
print(a) a = bool("啊")
print(a) a = bool(" ")
print(a) a = bool("")
print(a) a = str(True)
print(type(a),a) a = str(False)
print(type(a),a)
字符串详解:
索引(下标):
从左往右,开头为0
从右向左,结尾为-1
索引的条件不能超出索引本身最大值
a = "alex_wu_sir,_tai_bai_日魔"
print(a[5])
print(a[6])
print(a[11])
print(a[-2])
print(a[-1])
切片:
[起始位置:终止位置]----原则:顾头不顾尾
终止位置可以超出索引本身
[::-1]----从头到尾字符串反转
a = "alex_wu_sir,_tai_bai_日魔"
print(a[21:100])
print(a[21:]) [21(起始位置):(默认到最后)]
print(a[:]) [(默认从最开始):(默认到最后)]
print(a[0:-2])
步长:
步长决定了查找时迈的步子
步长决定了查找的方向
[起始位置:终止位置:步长]
[::-1]----从头到尾字符串反转
name = "alex,wusir,太白金星,女神,吴超"
1.太金
print(name[11:15:2])
2.神女
print(name[-4:-6:-1])
3.星白
print(name[-7:-13:-2])
4."alex,wusir,太白金星,女神,吴超" 整体反转
print(name[::-1])
***** 面试题的答案print(name[10:10000:200000])
字符串的方法
upper()--全部大写
lower()--全部小写
startswith()--以……开头
endswith()--以--结尾
replace()--把……替换成……
count()--统计字符出现的次数
strip()--脱(删除前后出现的空白)
split()--分割(默认空格,换行符\n,制表符\t)
format()--字符串格式化,填充
1. name = "{}今年:{}".format("宝元",18) # 按照位置顺序进行填充
print(name)
输出:宝元今年:18
2. name = "{1}今年:{0}".format("宝元",18) # 按照索引进行填充print(name)
输出:18今年:宝元
3. name = "{name}今年:{age}".format(name="宝元",age=18)
# 按照名字进行填充print(name)
输出:宝元今年:18
isdigit()--判断字符串中的内容是否全是数字
isdecimal()--判断是不是十进制数
isalnum()--判断是不是数字,字母,中文
isalpha()--判断是不是字母,中文
for 循环
- for:关键字
- i : 变量名(可以随意更改)
- in :关键字
- msg:可迭代对象(python数据类型中,除了int,bool其余都可以迭代)
Day 02
列表
数据类型之一,存储数据,大量的,存储不同类型的数据
列表是一种有序的容器 支持索引
列表是一种可变数据类型 原地修改
列表中只要用逗号隔开的就是一个元素,字符串中只要是占一个位置的就是一个元素
1.1 列表的增加:
- lst.append() 追加(在最末尾的地方进行添加)
- lst. insert() 插入
- lst.extend() 迭代添加
1.2 列表的删除
- lst.clear() 清空
- lst.pop() 删除
- lst.remove() 移除
del lst[4] # 通过索引删除
del lst[2:5] # 通过切片删除
del lst[1:5:2] # 通过步长删除
print(lst)
1.3 列表的修改:
- 通过索引进行修改:
lst = [1,2,3,4,5]
lst[2] = 80 通过索引进行修改
print(lst)
通过切片进行修改:
lst = [1,2,3,4,5]
lst[1:3] = "20" # 通过切片进行修改,默认步长为1,修改的内容必须是可迭代的对象,修改的内容可多可少
print(lst)通过步长进行修改:
lst = [1,2,3,4,5]
lst[1:5:2] = 100,100 # 步长不为1的时候,必须一一对应
print(lst)
1.4 列表的查:
使用for 循环索引
lst = [1,2,3,4,5]
for i in lst:
print(i)
1.5 列表的嵌套:
lst = [1,2,[3,4,5,["alex[]",True[[1,2,]],90],"wusir"],"taibai"]
lst1 = lst[2]
[3, 4, 5, ['alex[]', True, [[1, 2]], 90], 'wusir']
lst2 = lst1[3]
['alex[]', True, [[1, 2]], 90]
str_1 = lst2[0]
print(str_1[-1])
print(lst[2][3][0][-1])
结果:输出"alex[]"的右边的中括号
元组
2.1 关键字及特性:
- 关键字:tuple
- 特性:有序、不可变
- 格式:(1,2,3) #使用圆括号以及逗号分隔开
2.2 元组的方法:
元组支持查询,元组就是一个不可变的列表
方法:统计、获取索引
tu = (1,2,3,4,5,1,2,1)
print(tu.count(1)) # 统计tu元组中“1”的个数 tu = (1,2,3,4,5,1,2,1)
print(tu.index(2)) # 通过元素查询索引“2”的位置
2.3 元组的用途:
在配置文件中使用
2.4 元组的嵌套:
tu = (1,2,3,4,(5,6,7,8,("alex","wusir",[1,23,4])))
print(tu[4][4][0])
结果:“alex”
range 范围
3.1 用途:为了解决不能循环数字、
3.2 range中py2与py3 的区别:
print(range(1,10)) Python3中打印range是自己range自己本身
print range(1,10) Python2中打印range获取的是一个列表,列表的元素是1-9
3.3range方法:
range(1,10) [起始位置:终止位置] 顾头不顾尾
range(1,10,2) [起始位置:终止位置:步长] 默认为 1
range(10) 10代表的是终止位置,起始位置默认为 0range是一个可迭代对象
for i in range(2,10,2):
print(i) # 输出2 4 6 8
for i in range(100,-1,-1):
print(i) # 输出100-0
Day 03
字典:
定义:dict
dict = {"key":"value"} -- 键值对
作用:存储大量数据,数据和数据起到关联作用
所有的操作都是通过键来完成
键:必须是不可变的数据类型(可哈希),且唯一不可变
值:任意的数据类型
字典是可变的数据类型,无序的
字典的增:
暴力添加:dict["key"] = "value"
- 添加一个键值对,可以是列表
有责添加,无则不添加
dict。setdefault(“key”,“value”)
dic = {
"日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
"炮手":"飞机",
"豹哥":"贴膏药",
"宝元":"宝剑",
"alex":"吹牛逼"
}
dic.setdefault("元宝",["唱","跳","篮球","喝酒"])
print(dic)setdefault分为两步:
- 先查看键是否在字典中
- 不存在的时候进行添加
字典的删
- dict.pop() -- pop删除字典中的键进行删除,返回的也是删除的值
- dic.popitem() -- 随机删除 python3.6是删除最后一个
- dict.clear()-- 清空
- del dict -- 删除的是整个容器
- del dic["key"] -- 通过键进行删除
字典的改
- dic["key"] = "value" -- 有则覆盖,无则添加
- dict.update() --- 当update中的字典里没有dic中键值对就添加到dic字典中,如果有就修改里边对应的值
字典的查
dict.get("key") -- 查询不到就返回None
dic.get("key","定制内容") --- 查找不到就返回自己输入的定制内容
dict.setdefault("key") --- 查询不到返回None
dict.["key"] -- 查询不到就报错
查看所有的键
for i in dic: # 查看所有的键
print(i)查看所有的值
for i in dic: # 查看所有的值 print(dic.get(i))
获取到的是一个高仿列表
print(dic.keys()) # 获取到的是一个高仿列表
print(dic.values()) # 获取到的是一个高仿列表高仿列表支持迭代,不支持索引
面试题:
a = 10
b = 20
a,b = b,a
print(a)
print(b)dic = {"key1":2,"key2":4}
a,b = dic
print(a)
print(b)
解构的作用:
两个都是列表的时候才可以相加
lst = [1,2,3,4,5,6,7,8]
lst1 = lst[:2]
两个都是列表的时候才能够相加 lst1.append(lst[4])
for i in lst1:
print(i)*是万能接受
lst = [1,2,3,4,5,6,7,8]
a,b,c,d,e,*aa = lst # *是万能接受print(a,b,e)字典嵌套查找的时候一定是按照键一层一层进行查
Day 04
小数据池
- int: -5~256
- str:
- 字母,数字长度任意符合驻留机制
- 字符串进行乘法时总长度不能超过20
- 特殊符号进行乘法时只能乘以0
代码块:
一个py文件,一个函数,一个模块,终端中的每一行都是代码块
- int:-5~无穷大
- str:
- 定义字符串的时候可以是任意的
- 字符串(字母,数字)进行乘法时总长度不得超过20
- 特殊字符(中文,符号)进行乘法时乘以0或者1
- bool:
- True
- False
is是判断两边的内存地址是否相同
==判断两个值是否相等
代码块、小数据池同在的情况下先执行代码块。
驻留机制:节省内存空间,提升效率(减少了开辟空间和销毁空间的耗时)
集合
集合是python中的数据类型之一
定义方式:set
- 集合就是一个没有值的字典
字典的值:唯一,不可变
集合:无序,可变
集合天然去重
# s = {1,23,4,2,1,2,3,1}
print(s)
输出结果:{1, 2, 3, 4, 23}# 面试题:
lst = [1,223,1,1,2,31,231,22,12,3,14,12,3] print(list(set(lst)))
输出结果:[1, 2, 223, 3, 231, 12, 14, 22, 31]s = {} #空字典
s = set() #空集合
增:
s = set() s.add("alex") #直接添加, 输出结果为:{'alex'} s.update("wusir") #迭代添加, 输出结果为:{'r', 'i', 'w', 's', 'u'} set("wusir") #迭代添加, 输出结果为:set()
删
s = {100,0.1,0.5,1,2,23,5,4}
s.remove(4) # 通过元素删除
print(s)
s.clear() # 清空
s.pop() # 随机删除 (最小的)
print(s)改:
- 先删后加
查:
- for 循环
其他操作:
- 差集--“-”
- 交集--“&”
- 并集--“|”-管道符
- 反交集--“^”
- 子集--“>”返回的是一个布尔值
- 父集(超集)--"<"返回的是一个布尔值
- 冻结集合:frozenset()
深浅拷贝
赋值:将多个变量指向一个同一个内存地址就是赋值
浅拷贝:
只拷贝第一层元素的地址,只有修改第一层的时候元数据不受影响
给可变数据类型进行添加的时候源数据会受影响
= 是修改,.append是添加
可变数据类型能够添加和修改,不可变数据类型只能修改
a = [1,2,3,[4,5]]
b = a[:] # 浅拷贝
print(id(a[-1][0]))
print(id(b[-1][0]))
a.append(9)
print(a)
print(b)a = [1,2,3,[4,5,6,[9,10]],67]
b = a # 赋值
b = a[:]
a[-2].append(10)#[1, 2, 3, [4, 5, 6, [9, 10], 10], 67]
a[-2][-1].append(10)#[1, 2, 3, [4, 5, 6, [9, 10, 10]], 67]
print(b)
深拷贝:不可变数据类型内存地址共用,可变数据类型新开辟一个空间
# import copy # 导入 copy模块
a = [1,2,3,[4,5],6]
b = copy.deepcopy(a)
print(id(a[-2]))#2812949845896
print(id(b[-2]))#2812949847304
print(a)
print(b)
print(a == b) #True
print(id(a),id(b))
print(a is b) #False
可变数据类型:list(列表),dict(字典),set(集合)
不可变数据类型:int(整型),str(字符串),tuple(元祖),bool(布尔值)
Day 05
基础数据了类型补充:
字符串:str
- 首字母大写:capitalize
- 每个单词的首字母大写:.title()
- 大小写转换:.swapace()
- 居中及填中:.center(数字,''参数'')
- 居中:.center(数字)
- 查找:.find()--通过元素查找索引,查找不到时返回-1
- 查找:.index()--通过元素查找索引,查找不到时报错
- 列表+列表 str + str
- 列表相乘 str * 5
- 字符串相加或者相乘,都是开辟一块新的空间
列表:list
通过元素查找索引:.index()
排序:
- .sort()--默认从小到大,升序
- .sort(reverse = True)-- 降序
人工降序:
lst = [1,23,4,5,7,8,9]
lst.sort()
lst.reverse() #人工降序 print(lst)反转:.reverse()
反转:.reverse()
lst = [1,23,4,5,7,8,9] lst.reverse()
print(lst) # 将源数据进行反转不修改元数据进行反转:
lst = [1,23,4,5,7,8,9]
lst1 = lst[::-1]
print(lst)
print(lst1) # 不修改源数据进行反转列表相加:
lst = [1,2,3,4]
lst = lst + [1,2,3]
print(lst) # [1,2,3,4,[1,2,3],] [1,2,3,4,1,2,3]列表相乘:列表进行乘法运算时,元素是共用的
lst = [1,2,3] * 5
print(lst) print(id(lst[0]),id(lst[3])
元祖:tuple
tu = (1,[]) * 3
print(tu) #输出结果:(1, [], 1, [], 1, []) tu[-1].append(10)
print(tu) #输出结果:(1, [10], 1, [10], 1, [10])字典:dict
dict.popitem() 随机删除,3.6版本默认删除最后一位
dic = {}
dic.fromkeys("abc",[]) # 批量创建键值对 "a":[],"b":[],"c":[]
print(dic) #输出的结果为:{}dic = {}
dic = dic.fromkeys("abc",[])
print(dic)
dic["b"] = 11
dic["a"].append(10)
print(dic)
输出结果为:{'a': [10], 'b': 11, 'c': [10]}fromkeys第一个参数必须是可迭代对象,程序会将可迭代对象进行迭代成为字典的键,第二个参数是值(这个值是共用的)
fromkeys 共用的值是可变数据类型就会有坑,不可变数据类型就没事
可变数据类型:列表(list),字典(dict),集合(set)
不可变数据类型:字符串(str),整型(int),布尔值(bool),元祖(tuple)
有序数据类型:字符串(str),列表(list),元祖(tuple)
无序的数据类型:字典(dict),集合(set)
可以用索引取值:列表(list),元祖(tuple),字符串(str)
可以用键取值:字典(dict)
直接取值:整型(int),布尔值(bool),集合(set)数据类型转换:
1. 字符串转整型:int(str)
2. 整型转字符串:str(int)
3. 字符串转布尔值:bool(str)
4. 布尔值转字符串:str(bool)
5. 整型转布尔值:bool(int)
6. 布尔值转为整型:int(bool)
7. 列表转元祖:tuple(list) print(tuple(list))
8. 元祖转列表:list(tuple) print(list(tuple))
9. 列表转集合:set(list)
print (set(list))
10. 集合转列表:list(set)
print(list(set))
11. 元祖转集合:set(tuple)
12. 列表转字符串:使用join,
如下所示:
list -- str
lst = ["1","2","3"] print("".join(lst))
13.字符串转列表:使用分割
str -- list
s = "alex wusir 太白" print(s.split())重点: 列表乘法,
find用法
join用法
元祖形式:(1,)--有逗号的才是元祖 元祖乘法
字符串转列表
列表转字符串
以后遇到的坑
死循环:
lst = [1,2,3]
for i in lst:
lst.append(4)
print(lst)使用for循环清空列表元素内容
从前向后删除
创建一个新的容器,循环新的容器删除旧的容器内容
lst = [1,[2]]
lst[1] =lst
print(lst)
答案:[1,[...]]字典和集合:
dic = {"key":1,"key1":2}
for i in dic:
if i == "key1":
dic[i] = dic[i] + 8
dic[i] = 10
else:
print("没有这个键!")
print(dic)字典和集合在遍历(循环)时不能修改原来的大小(字典的长度),可以进行修改值
s = {1,2,3,4,5,6}
for i in s:
s.pop()
print(s)
二次编码
编码:
- ascii码:
- 支持英文,数字,符号 1字节
- 不支持中文
- gbk(国标)
- 支持英文,数字,符号 1字节
- 支持中文 2字节
- unicode(万国码):
- 支持英文,数字,符号 4字节
- 支持欧洲 4字节
- 支持亚洲 4字节
- utf-8:
- 支持英文,数字,符号 --1字节
- 支持欧洲 --- 2字节
- 支持亚洲 ---- 3字节
- ascii码:
字节:存储和传输
- 编码
今天是个好日子
s = "今天" # b'\xe4\xbb\x8a\xe5\xa4\xa9'
s1 = s.encode("utf-8") # 编码
print(s1)解码
print(b"meet") #只有字母才能这么搞
s2 = s1.decode("utf-8") #解码
print(s2)
# 必会 #
python3: 默认编码unicode
pyhton2:默认编码ascii
python2不支持中文 # 重要:
encode() # 编码 # decode() # 解码
用什么编码就要用什么解码 # 网络传输一定是字节
从入门到自闭之python初识的更多相关文章
- 从入门到自闭之Python基础——函数初识
1. 文件操作: 读操作: 格式:f = open("文件路径",mode = "r",encoding = "utf-8") f : 代表 ...
- 从入门到自闭之Python函数初识
函数初识 定义:def--关键字 将某个功能封装到一个空间中就是一个函数 功能: 减少重复代码 函数的调用 函数名+():调用函数和接收返回值 函数的返回值 return 值 == 返回值 ...
- 从入门到自闭之Python解释器安装
Python解释器的安装 1 下载 下载地址:https://www.python.org 选择windows平台的链接进行下载 https://www.python.org/downloads/ ...
- 从入门到自闭之Python集合,深浅拷贝(大坑)
小数据池 int: -5~256 str: 字母,数字长度任意符合驻留机制 字符串进行乘法时总长度不能超过20 特殊符号进行乘法时只能乘以0 代码块: 一个py文件,一个函数,一个模块,终端中的每一行 ...
- 从入门到自闭之Python整型,字符串以及for循环
Day 01 整型: 对比: 在python 2 版本中有整型,长整型long 在python 3 版本中全部都是整型 用于计算和比较 整型和布尔值的转换 二进制转换成十进制: print (in ...
- 从入门到自闭之Python while如何使用
while 循环 while 条件: 循环体 终止循环的两种办法: 改变条件 break break和continue的用法: break 用法:打破当前循环,(终止当前循环),所处位置在循环 ...
- 从入门到自闭之Python入门
python是一门解释型编程语言 变量名命名的规则: 变量名由字母,数字,下划线组成 变量名不能以数字开头 变量名要具有可描述性 变量名要区分大小写 变量名禁止使用python关键字 变量名不能使用中 ...
- 从入门到自闭之Python序列化
序列化(背) json :将数据类型转换成字符串(序列化),将字符串装换成原数据类型(反序列),支持dict,list,tuple等,序列后都变成了列表 dumps,loads ------ 用于网络 ...
- 从入门到自闭之Python名称空间
名称空间: 内置空间:python解释器自带的一块空间 全局空间:py文件中顶格写的就是全局空间 局部空间:函数体中就是局部空间 加载顺序: 内置空间 全局空间 局部空间 # def func(): ...
随机推荐
- Angular 主从组件
此刻,HeroesComponent 同时显示了英雄列表和所选英雄的详情. 把所有特性都放在同一个组件中,将会使应用“长大”后变得不可维护. 你要把大型组件拆分成小一点的子组件,每个子组件都要集中精力 ...
- 多态:JVM是如何进行方法调用的
在我们平时的工作学习中写java代码时,如果我们在同一个类中定义了两个方法名和参数类型都相同的方法时,编译器会直接报错给我们.还有在代码运行的时候,如果子类定义了一个与父类完全相同的方法的时候,父类的 ...
- 17.Python print()函数高级用法
前面使用 print() 函数时,都只输出了一个变量,但实际上 print() 函数完全可以同时输出多个变量,而且它具有更多丰富的功能. print() 函数的详细语法格式如下: print (val ...
- JS框架_(JQuery.js)图片相册掀开切换效果
百度云盘 传送门 密码:y0dk 图片掀开切换效果: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN&quo ...
- Jmeter -- 入门,基础操作
1. 添加线程组 设置线程组参数(线程数.准备时长.循环次数等): a)线程数:虚拟用户数.一个虚拟用户占用一个进程或线程.设置多少虚拟用户数在这里也就是设置多少个线程数. b)Ramp-Up Per ...
- 13.多线程设计模式 - Future模式
多线程设计模式 - Future模式 并发设计模式属于设计优化的一部分,它对于一些常用的多线程结构的总结和抽象.与串行相比并行程序结构通常较为复杂,因此合理的使用并行模式在多线程并发中更具有意义. 1 ...
- kotlin 简单处理 回调参数 加?
Kotlin Parameter specified as non-null is null 2017年10月18日 17:21:49 amiko_ 阅读数:9017 版权声明:本文为博主原创文 ...
- typescript 类(类的定义、继承、修饰符、抽象类)
代码: // 本节内容 // 1.类的定义 // 2.类的继承 // 3.访问修饰符 // 4.静态属性和静态方法 // 5.抽象类和多态 // js // function Person(name) ...
- leetcode-hard-array-54. Spiral Matrix-NO
mycode 思路:这种方格图一定要预先设置定位的变量,例如最大的长.宽,变化中的长.宽,在while循环中也要不断判断是否满足break条件 class Solution(object): def ...
- leetcode-easy-listnode-206 reverse linked list
mycode 98.87 # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x ...