python2与python3的区别( 如有错误，欢迎指点，不断的学习，会不断更新)
python定位：优雅、简单、明确
宏观上
python2：源码重复率高，不规范
语言分：编译型、解释型
编译型：一次性将所有程序编译成二进制文件
优点：运行速度快
缺点：开发效率低，不能跨平台
如：C、C++等等
解释型：当程序执行时，一行一行解释
优点：开发效率高，可以跨平台
缺点：运行速度慢
如：python、php等等
注释：
单行注释用：#
多行注释用英文的：''' 注释内容 '''
常见数据类型：
int：整数型
主要用计算，使用不多，记住以下就行：
加：+ 减：- 乘：* 除： / 取余：% 整除：// 幂：**
取值范围：
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
i = 2
print(i.bit_length()) # 求转换为二进制是 这个变量数据的 位数
bit_length
1 0000 0001 1
2 0000 0010 2
3 0000 0011 2
s = str(i) # int 转换为字符串
b = bool(i) # int 转换为布尔值 只有0是False 非0都是True
bool：布尔型，如：True、False
True 真 1
False 假 0
#同上 布尔值转换为int 只 能输出 0 和 1
i=int(True)
b=int(False)whileTrue:pass
while 1: #这个效率更高，因为电脑只识别0101二进制，True还要转换以下
pass
str：字符串，一般用英文：'内容' , "内容" , ''' 内容：多行''' ，
可以相加，可以数字加乘，存放少量数据
同上 字符串转换为 int 或布尔值
c= "123"b= int(c) #注：字符串转换为int 前提条件必须是 数值类型
字符串转换为布尔值
s= "" -->False#非空字符串都是True
sifs:print('你输入的为空，请重新输入')else:pass
# 字符串的索引与切片
s = 'ASDFGHJKL'
#索引 字符串有一定顺序，且从0开始
s1 = s[0] # 新的s1与上面的s已经没有任何关联
print(s1)
>> A
s3 = s[-1] # 如果字符串很长，我又去最后几位 就可以倒着取
print(s3)
>> L
# 切片 取后不取前
s2 = s[0:4] # 不影响s哦
print(s2)
>> ASDF
s4 = s[0:] # 全部取，你以为是 = [0:-1] 你会发现最后一位没取，记得取后不取前
s5 = s[:] # 也可以这样写哦！
print(s4,s5)
>> ASDFGHJKL ASDFGHJKL
# 跳这取 s[首:尾:步长]
s6 = s[0:6:2]
print(s6)
>> ADG
# 倒着切
s7 = s[4:0:-1]
print(s7)
>> GFDS
s8 = s[4::-2] # 倒着跳取 到最前面那位
print(s8)
>> GDA
s9 = s[-1::-1] # 倒着取完
print(s9)
>> LKJHGFDSA
s10 = s[::-1] # 倒着取完另一种方法
print(s10)
>> LKJHGFDSA
# 字符串的操作
s = 'asdfghj'
# capitalize 首字母大写
s1 = s.capitalize()
print(s1)
>> Asdfghj
# upper 全部大写
s2 = s.upper()
print(s2)
>> ASDFGHJ
'''
# 一道题 请输入验证码的题
s21 = 'sdFG'
s22 = input("请输入验证码，不区分大小写 ")
if s21.upper() == s22.upper():
print('验证码正确')
else:
print('验证码错误')
'''
# lower 全部小写
s3 = s.lower()
print(s3)
>> asdfghj
# swapcase 大小写翻转
s4 = s.swapcase()
print(s4)
>> ASDFGHJ
# title 每个隔开(特殊字符或数字)单词首字母大写
s5 = 'asd vbn fgh'
s51 = s5.title()
print(s51)
>> Asd Vbn Fgh
# center 填充
s6 = s.center(20) # 居中填充 不写默认空白填充
s61 = s.center(10,'*') # 可以跟参数 10是算字符串总的为 不满用参数填充
print(s6,s61)
>> asdfghj *asdfghj**
# \t 加上前面所占不到8位补8位，超过8位不足16位补16位
s7 = 'fg\tkl'
s71 = s7.expandtabs()
print(s71)
>> fg kl
# len 计算字符串长度
s8 = len(s)
print(s8)
>> 7
# startswith 判断字符串是否以什么开头只能返回 True和False ，后面不加条件 就判断整体
s9 = 'asdDFG'
s91 = s9.startswith('a')
s92 = s9.startswith('d',2,5) # 可以切片判断
print(s91,s92)
>> True True
# find 通过元素 找元素所占的索引，找不到就返回-1
s9 = 'asdDFG'
s10 = s9.find('D')
s101 = s9.index('D') # 另一种方法 找不到会报错 ，首选find
print(s10,s101)
>> 3 3
# strip 删除前后元素 默认删除前后空格
s11 = ' hjkl '
s111 = s11.strip()
s112 = '$%kljflk*'
s113 = s112.strip('*$%') # 可以加参数，里面不按顺序
s114 = s112.rstrip('*$%') # 从右删，左边不动，同理 lstrip：从左删 右边不动
print(s111,s113,s114)
>> hjkl kljflk $%kljflk
# 附一道小题
# username = input('请输入你的名字：')
# if username.strip() == '小米':
# print('答对了')
# count 计数
s12 = s.count('a') # 数字符串所有的元素，也可以两个一起'as'
print(s12)
>> 1
# split 分割 也是字符串转换成列表的一种方式
s13 = 'kjh jkjhk kjhjk'
s131 = s13.split() # 括号里是参数，分隔后参数是不显示的
print(s131)
>> ['kjh', 'jkjhk', 'kjhjk']
str.split(str="", num=string.count(str))#第一个是以哪个参数分割 ，num这个字符串里有多个参数 分割次数，num有指定值则分割num+1，默认为-1，即分割所有
s = 'alexwusirlex'li= s.split('l',1) #以l分割第一个
print(li)#>> ['a', 'exwusirlex']
#format 格式化输出
s14 = '我叫{},今年{},喜欢{}'.format('huang',25,'girl')
s141 = '我叫{0},今年{1},喜欢{1}'.format('huang',25,'girl')
s142 = '我叫{name},今年{age},喜欢{hobby}'.format(name='huang',age=25,hobby='girl')
print(s14,s141,s142)
>> 我叫huang,今年25,喜欢girl 我叫huang,今年25,喜欢25 我叫huang,今年25,喜欢girl
# replace 替换
s15 = '我来看你了你知道吗你知道吗'
s151 = s15.replace('知道','haha',1) # 替换 目标，值 ，有相同的第几个
print(s151)
>> 我来看你了你haha吗你知道吗
tuple：元组，元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。
例：(1，2，3)("a","b","c")
# 元组 只读列表 可循环查询 可切片 儿子不能改 孙子可能可以改
ts = ('name','age','column',[1,2,'hello'],'man')
print(ts[3][2]) # 查
>> hello
ts[3][2] = ts[3][2].upper() # 改孙子元素
print(ts)
>> ('name', 'age', 'column', [1, 2, 'HELLO'], 'man')
ts[3].append('ha') # 添加
print(ts)
>> ('name', 'age', 'column', [1, 2, 'hello', 'ha'], 'man')
#python range() 函数可创建一个整数列表，一般用在 for 循环中。#
#函数语法#range(start, stop[, step])#参数说明：#start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0， 5);#stop: 计数到 stop 结束，但不包括 stop。例如：range(0， 5) 是[0, 1, 2, 3, 4]没有5#step：步长，默认为1。例如：range(0， 5) 等价于 range(0, 5, 1)
for i in range(0,10): #(开始，结束，步长)
print(i)>> 0 1 2 3 4 5 6 7 8 9
for s in range(10,0,-2):print(s)>> 10 8 6 4 2
for d in range(3,-10,-2):print(d)>> 3 1 -1 -3 -5 -7 -9
# 一道题 两种方法参考
li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds'] # 都打印出来 包括里面的列表元素
# for i in li:
# if type(i) == list:
# for k in i:
# print(k)
# else:print(i)
for i in range(len(li)):
if type(li[i]) == list:
for j in li[i]:
print(j)
else:print(li[i])
list：列表：[] 括起来，每个元素以逗号隔开，可以存储大量数据，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。
而且列表是有序的，有索引值，可切片，方便取值。
# 列表 增删改查
# 增加 append 还在基础上增加 没有创建新的
p.append('happy,new year')
print(p)
# HR 输入名字 持续增加 当输入Q的时候 就退出
# while 1:
# username = input('>>>')
# if username.strip().upper() == 'Q':
# break
# else:
# p.append(username)
# print(p)
# insert 插入
p.insert(4,'老铁')
print(p)
# extend 插入可迭代的元素
p.extend('你好')
p.extend([1,2])
print(p)
# 删 pop
p2 = p.pop() # 有返回值 不填参数 默认删最后一个
p21 = p.pop(4) # 指定索引位删
print(p,p2,p21)
# remove 按元素删
p.remove('i love you')
print(p)
# clear 清空列表 但不删列结构
p.clear()
print(p)
# del
del p[0:2] # 切片删
del p # 全删包括列
print(p) # 你会发现报错 ，因为没有了，所以他肯定报错
# 改
p[0] = '你好' # 直接对应的 索引位改
p[0] = [4,5,6] # 也可以直接改列表
p[0:3] = '你好' # 把前三个删了 划分到最小的元素添加
p[0:3] = ['hao','ba'] # 添加列表里每一个元素
print(p)
# 查
print(p[0:4]) # 直接查
l = len(p) # 查列表长度
print(l)
# count 查一个元素的次数
print(p.count('ba'))
# index 查元素在列表中的索引位
print(p.index('hao'))
# sort 排序
s = [1,6,5,9,10]
s.sort() # 正向排序
print(s)
s.sort(reverse = True) # 倒向排序
print(s)
s.reverse() # 翻转
print(s)
# 列表的嵌套
t = ['xiaomi','haha','happy new year',1,2]
print(t[1][1]) # 找里面元素的元素
name = t[1].capitalize() # 所选的元素的首字母大写，但里面本质没有改变
print(name)
print(t)
t[0] = name # 这样里面元素已经改变
print(t)
print(t[2].replace('h','好')) # 里面元素替换
t[2] = t[2].replace('h','好')
print(t)
#列表转换成 字符串 join 字符串转换成列表 split
s ='huang's1= '+'.join(s) #可以对可迭代对象任何操作
print(s1)#>> h+u+a+n+g
#''.join()
li = ['alex','wusir','rain']
s2= ''.join(li)print(type(s2))print(s2)#>> #>> alexwusirrain
dict：字典，用{ } 括起来，key不存在重复
'''
# dict
# 数据类型划分：可变、不可变
# 不可变 ：元组、bool、int、str 可哈希
# 可变：list、dict、set 不可哈希
# dict key 必须是不可变得数据类型 可哈希
value 任意数据类型。
dict 优点：二分查找去查询、存储大量的关系型数据
特点：3.5版之前是无序的
'''
dict = {
'name':'小米',
'age':'18',
'p1':[{'xuexi':15},20]
}
# 增
dict['hello'] = 'world'
print(dict)
# >> {'name': '小米', 'age': '18', 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
# 如果有了 会直接覆盖掉
dict['age'] = 25
print(dict)
# >> 'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
# setdefault
dict.setdefault('身高') # 没有vlaue会填充None
print(dict)
# >> {'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
dict.setdefault('age','20') # 对里面有键值对，不做任何改变，没有参会添加
print(dict)
# >> {'name': '小米', 'age': 25, 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
# 删
# pop
print(dict.pop('age')) # 有返回值
print(dict)
# >> 25
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
print(dict.pop('age',None)) # 如果字典里没有你要删除的键值对，你就要加个返回值，可自定义 防止报错飘红
print(dict)
# >> None
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world', '身高': None}
# popitem
print(dict.popitem()) # 删除最后一个，3.5以前随机删除 ，返回值 删除的键值对
print(dict)
# >> ('身高', None)
# >> {'name': '小米', 'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
# del
del dict['name'] # 所在键值对不在时会报错
print(dict)
# >>{'p1': [{'xuexi': 15}, 20], 'hello': 'world'}
dict.clear() # 清空字典
print(dict)
# >> {}
# 改
# 直接改
dict['age'] = 18
print(dict)
# >> {'age': 18}
# update
dict1 = {'name':'xiaomi','hello':'world'}
dict.update(dict1) # 把dict1的全部键值对 添加到 dict ，相同的覆盖
print(dict1)
print(dict)
# >> {'name': 'xiaomi', 'hello': 'world'}
# >> {'age': 18, 'name': 'xiaomi', 'hello': 'world'}
# 查
print(dict.keys())
print(dict.values())
print(dict.items())
# >> dict_keys(['age', 'name', 'hello'])
# >> dict_values([18, 'xiaomi', 'world'])
# >> dict_items([('age', 18), ('name', 'xiaomi'), ('hello', 'world')])
v1 = dict['name'] # 输出是值，没有就会报错
print(v1)
# >> xiaomi
# get
print(dict.get('name')) # 有就会直接返回值 没有就会返回None
print(dict.get('name2','没有这个值')) # 也可以自定义
# >> xiaomi
# >> 没有这个值
a,b = 1,2
a,b = [1,2]
a,b = [1,2],[3,4]
print(a,b)
# >> 1 2
# >> 1 2
# >> [1,2] [3,4]
# 用一行代码把 a b 值交换
a = 1
b = 2
a,b = b,a
print(a,b)
# >> 2 1
# 一一对应，接受值
for k,v in dict.items():
print(k,v)
# 嵌套
dic = {
'name':['xiaomi','zhangsan','lisi'],
'jihe':{
'time':'123',
'learn_money':19800,
'leader':'huang'
},
'age':18
}
# 改
dic['age'] = 25
print(dic)
#>> {'name': ['xiaomi', 'zhangsan', 'lisi'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['name'].append('leader')
print(dic)
# >> {'name': ['xiaomi', 'zhangsan', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['name'][1] = dic['name'][1].upper() # 其中一个值改大写
print(dic)
# 》{'name': ['xiaomi', 'ZHANGSAN', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang'}, 'age': 25}
dic['jihe']['gou'] = 8
print(dic)
# >> {'name': ['xiaomi', 'ZHANGSAN', 'lisi', 'leader'], 'jihe': {'time': '123', 'learn_money': 19800, 'leader': 'huang', 'gou': 8}, 'age': 25}
# 一道题
f = input('>>>')
for i in f:
if i.isalpha():
f = f.replace(i,'')
o = f.split()
print(o)
print(len(str(o)))
set：集合，用{ } 括起来，集合是无序的，不重复的数据集合，里面的元素是不可变类型
# is 比较，比较的事内存地址
'''
# 集合：可变的数据类型，它里面的元素必须是不可变得数据类型，无序，不重复，{}
set = {1,'sdfsd',2,3,'hello'}
# add 增加
set.add("name")
print(set)
# >> {1, 2, 3, 'name', 'sdfsd', 'hello'}
# update
set.update('leader')
print(set)
# >> {1, 2, 3, 'hello', 'a', 'd', 'name', 'l', 'r', 'sdfsd', 'e'}
# pop 删除
set.pop()
print(set.pop()) # 随机删除 有返回值
print(set)
# 》 1
# 》 {2, 3, 'd', 'r', 'l', 'sdfsd', 'hello', 'a', 'e'}
# remove
set.remove(2) # 按元素去删
print(set)
# 》{'sdfsd', 1, 3, 'hello'}
# clear 清除集合
set.clear()
print(set)
# >> set()
# del 删除整个集合
del set
print(set)
# >>
# 查
for i in set:
print(i)
# 求交集
set1 = {1,2,3,4,"hello"}
set2 = {1,4,2,5,"world"}
set3 = set1 & set2 # 第一种
print(set3)
# >> {1, 2, 4}
print(set1.intersection(set2)) # 第二种
# 》 {1, 2, 4}
# 求并集
print(set1 | set2)
# 》 {1, 2, 3, 4, 5, 'world', 'hello'}
print(set1.union(set2))
# >> {1, 2, 3, 4, 5, 'world', 'hello'}
# 反差集
print(set1 - set2)
# 》 {'hello', 3}
print(set1.difference(set2))
# >> {3, 'hello'}
# 子集 超集
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，若返回True 则set1是set2子集
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，若返回True 则set2是set1超集
'''
# set 本身是可变数据类型，但可以让他变成不可变数据类型，冻住
s = frozenset('barry')
print(s,type(s))
# >>frozenset({'b', 'r', 'a', 'y'})
# 一道小题 去重
li = [11,22,33,33,44,55,66,66,77]
set5 = set(li)
print(set5)
li = list(set5)
print(li)
complex：复数
float：浮点型 ，如：12.20
注：
type()：查看数据类型的方法
字符串转换成数字：int(str) ，条件str必须是数值组成
同样数字转换成字符串：str(int)
用户交互input输出的全部是 str
变量：由数字 字母 下划线任意组合，且不能以数字开头
具有可描述性
不能用python中的关键字
以下关键字不能声明为变量名 ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from',
'global', 'if', 'import','in', 'is', 'lambda', 'not','or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
常量：约定俗成 不可更改 ，全部是大写字母
版权声明：本站所有资料均为网友推荐收集整理而来,仅供学习和研究交流使用。
工作时间：8:00-18:00
客服电话
电子邮件
admin@qq.com
扫码二维码
获取最新动态
