• 欢迎光临~

总结小计

开发技术 开发技术 2022-10-07 次浏览

总结小计

目录
  • 总结小计
    • 一、python基础数据类型
        • 1、整型(int)
        • 2、浮点型(float)
        • 3、字符串(str)
        • 4、列表(list)
        • 5、字典(dict)
        • 6、布尔值
        • 7、元组(tuple)
        • 8、集合(set)
    • 二、与用户交互
        • 1、接收用户输入 (input)
        • 2、输出
    • 三、格式化输出
    • 四、运算符
        • 1、数学运算符
        • 2、比较运算符
        • 3、逻辑运算符
        • 4、成员运算符
        • 5、身份运算符
    • 五、常用赋值符
        • 1、链式赋值
        • 2、交叉赋值
        • 3、解压赋值
    • 六、垃圾回收机制
        • 1、什么是垃圾回收机制?
        • 2、为什么要用垃圾回收机制?
        • 3、垃圾回收机制原理分析
    • 七、流程控制
        • 1、顺序结构
        • 2、分支结构
        • 3、循环结构
        • 4、流程控制必备知识
    • 八、数据类型内置方法
        • 1、整型
        • 2、浮点型
        • 3、字符串
        • 4、列表
        • 5、字典
        • 6、元组
        • 7、集合

一、python基础数据类型

1、整型(int)

整型就是整数。

eg:
    age = 18

2、浮点型(float)

浮点型就是小数。

eg:
    height = 1.83

3、字符串(str)

字符串是文本类型的数据,引号引起来的部分都是字符串。

eg:
    hobby = '打游戏'

4、列表(list)

  • 列表可以存储多个数据。

  • 索引取值
    起始数字是从0开始
    l1[索引值]

eg:
    list = ['dog','cat' ,'pig','sheep','rabbit']

5、字典(dict)

字典可储存任意对象,以键值对key-value形式存储数据,包含在大括号或称花括号{}中。

eg:
    ID ={'username':['郑爽','吴亦凡','蔡徐坤']}

6、布尔值

布尔值反应条件的正确与否,主要用于流程控制中。

布尔值就两种,true,false。

布尔值为False的数据有:0,None,'',[ ],{ },其余为true。

eg:
    is_delete = False

7、元组(tuple)

Tuple的值用小括号括起来,括号内部存放多个数据值。

例:班里同学姓名
T = ('rose','lisa','nancy','bob')

8、集合(set)

集合是一个无序不重复元素的集,基本功能包括关系测试和消除重复元素。创建一个空集合,必须用set()而不是{},因为{}创建的是一个空字典。

s1 = {1, 2, 3, 4, 5, 6}

二、与用户交互

1、接收用户输入 (input)

"input"会将用户输入的内容都转化成字符串类型
name = input("请输入你的名字>>")  #输入"jason"
print(name)   #jason
passwd = input("请输入密码>>")   #"123"
print(type(passwd))   #<class 'str'>

  • Python2与Python3—input比较
python2中"input"有两种
1. "raw_input",等同于Python3中的"input"
2. "input",需要用户输入一个明确的数据类型,输入的什么类型就存成什么类型

2、输出

x = 1
y = 2
z = 3
print(x)  #1
print(2)  #2
print(x,y,z)  #1,2,3
"print"默认自带"n"
可以使用'end=""'来取消

三、格式化输出

格式化输出就是按照一定的格式输出内容。

在现实生活中大部分情况下使用下划线提示别人填写内容。 但是在程序中需要使用占位符:%s %d

info = '%s同志你好'
'''单个占位符'''
# print(info % 'Jason')  # Jason同志你好
# print('%s同志你好' % 'Tony')  # Tony同志你好
# print(info % ('jason',))
# print('%s同志你好' % ('Tony',))
'''多个占位符'''
# desc = '姓名:%s 年龄:%s 爱好:%s'
# print(desc % ('jason', 18, 'read'))
# print('姓名:%s 年龄:%s 爱好:%s' % ('tony', 28, 'rap'))
'''注意事项:有几个占位符就需要几个数据值'''
# print('my name is %s my age is %s' % ('jason',))  # 少了不行
# print('my name is %s my age is %s' % ('jason', 18, 'read'))  # 多了不行
'''不同占位符的区别'''
# demo1 = '%s您好 您本月的话费是%s 余额是%s'  # %s常见数据类型都支持
# print(demo1 % ('jason', 100, 10000000000000))
# demo2 = '%d您好 您本月的话费是%d 余额是%d'  # %d只支持数字类型
# print(demo2 % ('tony', 1000000000, -100000))

print('%08d'% 123)  # 00000123,数据值未满8位数用0自动填充,存折余额
print('%08d'% 1234324324)  # 1234324324 数据值超过设定的位数以数据值为准。

四、运算符

1、数学运算符

    + - * / % // **
    简化写法
    n = 10
    n += 1  # n = n + 1
    n -= 1  # n = n - 1
    n *= 1  # n = n * 1
    n /= 1  # n = n / 1
    n %= 1  # n = n % 1
    n //= 1  # n = n // 1
    n **= 1  # n = n ** 1

2、比较运算符

< > <= >= ==(等于号) !=(不等于)

3、逻辑运算符

与	and	条件都为真是结果为真
或	or  条件都为假是结果为假
非	not	取反
优先级:not > and > or

4、成员运算符

判断个体在不在群体内

in 是否包含个体
not in 是否不包含个体
eg:
    list = ['jason','tom','bob','may']
    print('jason' in list)
    print('lina' not in list)

5、身份运算符

  • id() 返回一串数字,该数字可以看成是内存地址
  • is 判断内存地址是否相同
  • == 判断数据值是否相同
  • 小整数池

整数在程序中的使用非常广泛,Python为了优化速度,使用了小整数对象池,避免为整数频繁申请和销毁内存空间。

五、常用赋值符

1、链式赋值

同一值不变情况下,分别赋值给多个变量

    x = 10
    y = 10
    z = 10
    x = y = z = 10

2、交叉赋值

交换两个变量的值

'''方式1:采用中间变量'''
    # temp = m
    # m = n
    # n = temp
    # print(m, n)  # 999 100
'''方式2:交叉赋值语法'''
    m, n = n, m
    print(m, n)  # 999 100

3、解压赋值

1、将列表中的多个值全部取出来依次赋值给多个变量名
#将列表中的多个值取出来依次赋值给多个变量名,可以这么做
myList = [1,2,3]
a = myList[0]
b = myList[1]
c = myList[2]

#利用解压赋值
a,b,c = myList #包含多个值,就好比一个压缩包,解压赋值因此得名
print(a,b,c) #1 2 3

#上述解压赋值,等号左边的变量名个数必须与右面包含值的个数相同,否则会报错

2、将列表中的多个值部分取出来依次赋值给多个变量名
可以将不取的多个部分用*_代替,单个值用_代替。
# 将列表中的前两个值取出赋值给变量a,b
myList1 = [1,2,3,4,5]
a,b,*_ = myList1
print(a,b) # 1 2
print(*_) # 3 4 5
print(_) # [3,4,5]

#将列表中前一个值和最后两个值取出赋给变量a,b,c
a,*_,b,c = myList1
print(a,b,c) # 1 4 5
print(*_) # 2 3
print(_) # [2,3]

#将列表中的前一个值赋值给a,最后一个值赋值给b,第二个给_,第3,4个为列表
a,_,*_,b = myList1
print(a,b) # 1 5
print(*_) # 3 4
print(_) # [3,4]
# 列表中值2"消失"了。单个 _ 表示该变量被废弃

六、垃圾回收机制

1、什么是垃圾回收机制?

垃圾回收机制专门回收不可用变量值所占用的内存空间。

2、为什么要用垃圾回收机制?

程序运行过程中会申请大量的内存空间,而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽,导致程序崩溃。为更好的管理内存制,使用Python解释器自带的垃圾回收机制来清理垃圾,释放内存。

3、垃圾回收机制原理分析

Python的垃圾回收机制主要运用了“引用计数”来跟踪和回收垃圾。在引用计数的基础上,还可以通过“标记-清除”解决容器对象可能产生的循环引用的问题,并且通过“分代回收”以空间换取时间的方式来进一步提高垃圾回收的效率。

七、流程控制

1、顺序结构

顺序结构就是从上而下的依序执行。

2、分支结构

根据某些特定的条件来做出判断,再做出不同的执行策略。

#单if分支结构
'''
if 条件:
	条件成立后执行子代码块
'''
if 3 > 1:
    print('3大于1')

#if...else...分支结构
'''
if 条件:
	条件成立之后执行的子代码块
else:
	条件不成立情况下执行的子代码块
	
ps:if与else连用 两者的代码块永远只会执行一个
'''
gender = 'male'
if gender == 'male':
    print('先生')
else:
    print('女士')
    
#if...elif...else分支结构
'''
if 条件1:
	条件1成立之后执行的子代码块
elif 条件2:
	条件1不成立,条件2成立之后执行的子代码块
elif 条件3:
	条件1和2都不成立,条件3成立之后执行的子代码块
....
else:
	上述所有条件都不成立,执行的子代码块
	
ps: elif可以有很多个
三者连用也只会执行其中的一个子代码块
'''
eg: 根据成绩评判分类
    大于90优秀 大于80良好 大于70一般 大于60及格 其他挂科
score = 79
if score > 90:
    print('优秀')
elif score > 80:
    print('良好')
elif score > 70:
    print('一般')
elif score 78> 60:
    print('及格')
else:
    print('挂科重修')
    
#if嵌套使用
age = 26
height = 165
weight = 99
is_beautiful = True
is_success = True
if age < 28 and height > 160 and weight < 100 and is_beautiful:
    print('小姐姐能否加个微信')
    # 判断小姐姐是否会给微信
    if is_success:
        print('吃饭 看电影 天黑了...')
    else:
        print('去你妹的 变态!')
else:
    print('可惜了')


3、循环结构

需事物的执行会根据某个条件出现重复,这个循环不可能一直持续,应该需要一个使循环结束的条件。

1、while循环结构

就是想让一些代码反复的执行,条件成立之后执行的子代码(循环体代码)。
eg:
count = 1
while count < 5:
print('hello world')
count += 1  # count = count + 1
print('想不想干饭?')

2、for循环

循环获取存储多个数据的数据内部数据值。
for循环语法结构
	for 变量名 in 待遍历的数据:
 		  for循环体代码
eg:
data = ['jason','tom','tony','kevin']  # 待遍历数据
for i in data:                         # 循环体代码
    print(i)
输出结果:
D:Python38python38.exe D:/pythonProject/111/1.py
jason
tom
tony
kevin
Process finished with exit code 0
#for循环特点
1.擅长遍历取值
2.不需要结束条件,自动结束(遍历完)

4、流程控制必备知识

  • 条件都会转成布尔值,从而决定子代码是否执行
  • 在python中使用缩进来表示代码的从属关系
  • 并不是所有的代码都可以拥有子代码
  • 同属于某个代码的多行子代码,必须要保持相同的缩进量,在python中推荐使用四个空格(tab)来缩进
    ps:上一行代码的结尾如果是冒号,那么下一行代码必缩进

八、数据类型内置方法

数据类型的内置方法是Python为提高开发效率,每个数据类型内置一些快速实现效果的快捷代码。

数据类型调用内置方法格式:

数据类型.方法名 ()
eg:
    'jason'.字符串内置方法

1、整型

int(转换的数据类型)
eg:
    age = input('name>>>:') # 这里输入的age是以字符串的形式进行
    age = int(age)  #这一步让age的数据类型由字符串转换为整型
    
    print(type(int('123a')))  # 报错,转换的字符串里不全是数字,出现了a,所以无法转换。
    print(type(int('123.123')))  # 报错,转换的字符串里有小数点也不行。
总结:整型转换时,转换的数据值里应该只有数字。
    

2、浮点型

float(转换的数据类型)
eg:
print(float('123')) #运行结果 123.0
print(float('123a')) # 报错,与整型一样,转换的数据值里只能是数字
print(float('123.321')) # 可以转换
print(float('123.21.12')) # 不可以,转换的数据值里只能有一个小数点

3、字符串

str(转换的数据类型)
#1、索引取值
起始位置0开始,超出范围直接报错。
s1=(1,2,3,4,5,)
print(s1[0])
# 输出结果1,[]里为索引值
s1可以是数列、元组
print(s1[-1])  
# 输出结果5,索引值支持负数,索引从末尾开始。

#2、切片操作
data = 'jason'
print(data[0])  # j
print(data[-1])  # n 负数就是从最后往前取
print(data[1:3])  # as 顾头不顾尾,从索引1一直切取到索引2
print(data[-1:-3]) # 空,取值顺序错误,默认顺序是从左往右
print(data[-1:2]) # 空,[-1:2]修改为[-1:2:-1]可取值
print(data[-1:-3:-1])  # on 第三个数是控制方向的

#3、修改切片方向(间隔)
print(s1[1:5:2])  # 默认是1,隔2索引
print(s1[-1:-5:-1]) #从右往左取值(索引-1,-2,-3,-4的值)
print(s1[:])  # 不写数字就默认都要,相当于[],输出s1所有的值
print(s1[2:])  # 从索引2开始往后都要
print(s1[:5])  # 从索引0开始往后要到4
print(s1[::2]) # 不写数字就默认都要,隔2索引

#4、统计字符串中字符的个数
eg:
s1=(1,2,2,6,9,6)
print(len(s1))  # 计算s1的长度,输出结果为6

#5、移除字符串首尾指定的字符 strip()
eg:
    username = input('username>>>:').strip()# 括号内不写,默认移除首尾的空格
    
#6、切割字符串中指定的字符 split()
 eg:
    data = 'hello|world'
    print(data.split('|'))  # 以|为间隔,断开
    # 输出结果为['hello', 'world']  # 以列表的形式产生
    当使用split()内置方法间隔开字符串的时候,字符串是以列表的形式产生的。
    
#7、字符串格式化输出 format()
eg:
res = 'my name is {} my age is {}'.format('jason', 123)
print(res)
# 输出结果为 my name is jason my age is 123 (format内置方法充当了%s的作用)

#8、大小写相关
lower() 将字符串里的字母的大写转换成小写
upper() 将字符串里的字母的小写转换成大写

#9、判断字符串中是否是纯数字 isdigit()

#10、替换字符串中指定的内容 replace()

#11、字符串的拼接 
格式:
	'间隔标识'.join(拼接在一起的字符串)
    
#12、统计指定字符出现的次数  count()

#13、判断字符串的开头或结尾
startswith()判断字符串的开头
endswith()判断字符串的结尾

#14、补充
title() 每个单词首字母大写
capitalize() 第一个字母大写
swapcase() 小写变大写,大写变小写

4、列表

list(其他数据类型)
把其他数据类型转成列表
#1、索引取值(正负数)
print(L1[0])
# 1,从左到右索引取数据值
print(l1[-1])
# 8,从右往左索引取数据值

#2、切片操作
L1 = [1,2,3,4,5,6,7,8]
print(L1[0:5])
# [1, 2, 3, 4, 5],索引切割0到4的数据值
print(L1[:])
# [1, 2, 3, 4, 5, 6, 7, 8],不写数字就默认都要,相当于[],输出L1所有的值

#3、间隔数、方向与字符串讲解操作一致
L1 = [1,2,3,4,5,6,7,8]
print(L1[::-1])
# [8, 7, 6, 5, 4, 3, 2, 1] 从右往左取值(全部),[::-1]只说明方向未规定范围

#4、统计列表中数据值的个数
len()
L1 = [1,2,3,4,5,6,7,8]
print(len(L1))
# 8 统计列表中数据值的个数

#5、数据值修改
L1 = [1,2,3,4,5,6,7,8]
L1[0] = 9
print(L1)
# [9, 2, 3, 4, 5, 6, 7, 8],通过索引将L1中的1改为9

#6、列表添加数据值
尾部追加数据值append()
L1 = [1,2,3,4,5,6,7,8]
L1.append('干饭')
print(L1)
# [1, 2, 3, 4, 5, 6, 7, 8, '干饭'],在列表尾部添加一个数据值
任意位置插入数据值insert()
L1 = [1,2,3,4,5,6,7,8]
L1.insert(0, 'jason')
print(L1)
# ['jason', 1, 2, 3, 4, 5, 6, 7, 8],
#()内前面是索引,然后在索引的位置添加()内后面的数据值
L1.insert(1, [11, 22, 33, 44])
# [1, [11, 22, 33, 44], 2, 3, 4, 5, 6, 7, 8]
# 将[11, 22, 33, 44]插入L1索引1的位置
扩展列表,合并列表extend()
ll1 = [11, 22, 33]
ll2 = [44, 55, 66]
print(ll1 + ll2) 
# [11, 22, 33, 44, 55, 66],合并ll1 + ll2为一个列表
ll1.extend(ll2)
print(ll1)
# [11, 22, 33, 44, 55, 66],使用extend()将ll2合并到ll1中
for i in ll2:
    ll1.append(i)
print(ll1)
#[11, 22, 33, 44, 55, 66],for循环+append()=extend()

#7、删除列表数据
方法一:通用的删除关键字del
l1 = [11, 22, 33]
del l1[0]
print(l1)
# [22, 33],删除l1中索引0对应的数据

方法二:remove
l1 = [11, 22,444 ,33]
l1.remove(444)
print(l1)
# [11, 22, 33] 直接拿走l1里的444

方法三:pop
l1 = [11, 22, 5,33]
l1.pop(3)
print(l1)
#[11, 22, 5] ,拿走l1里索引3对应的数据值
l1.pop()
print(l1)
#[11, 22, 5],默认从尾部弹出数据值

#8、排序
ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
sort()
ss.sort()
print(ss)
# [12, 33, 43, 54, 55, 76, 76, 88, 99, 99, 100]
# 使用sort()排序默认是升序
ss.sort(reverse=True)
print(ss)
#[100, 99, 99, 88, 76, 76, 55, 54, 43, 33, 12]
# 添加reverse=True逆转默认,将排序改为降序

#9、统计列表中某个数据值出现的次数
l1 = [111,2222,333,4444,111,666]
print(l1.count(111))
# 2 ,统计l1中数据值111出现的次数

#10、颠倒列表顺序
reverse()
l1 = [111,2222,333,4444,111,666]
l1.reverse()
print(l1)
# [666, 111, 4444, 333, 2222, 111]
#直接反过来打印列表l1

5、字典

dict()
字典中K值一般为字符串,只有是不可变数据类型就行。
字典中,K:V键值对是无序的。

#1、按k取值(不推荐使用)
l1 = {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(l1['name']) # jason
print(l1['phone']) # KeyError: 'phone',K值不存在会直接报错
按内置方法get取值(推荐使用)
get()
l1 = {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(l1.get('name')) # jason 
print(l1.get('age'))  # None, k值不存在不会报错
print(l1.get('name', '没有哟 嘿嘿嘿')) 
# jason   键存在的情况下获取对应的值
print(l1.get('age', '没有哟 嘿嘿嘿'))
# 键不存在默认返回None,可以通过第二个参数自定义

#2、修改值数据
l1 = {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1['name'] = 'kevin'  # 修改K值对应的V值
print(l1)  
# 输出结果:{'name': 'kevin', 'pwd': 123, 'hobby': 'read'}
# 键在则为修改
l1['age'] = 21
print(l1)  
# 输出结果:{'name': 'jason', 'pwd': 123, 'hobby': 'read', 'age': 21}
# 键不在则为新增

#3、删除数据
pop()
l1 = {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
l1.pop('name')
print(l1)  # 输出结果:{'pwd': 123, 'hobby': 'read'},弹出整个键值对
res = l1.pop('name'),定义变量
print(res)  # jason 接收弹出的键值

#4、统计字典中键值对的个数
len()
l1 = {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(len(l1))
# 3 统计字典中键值对的个数


#5字典三剑客
keys()
l1 = {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
print(l1.keys())
# dict_keys(['name', 'pwd', 'hobby']) 一次性获取字典所有的键

values()
print(l1.values())
# dict_values(['jason', 123, 'read']) 一次性获取字典所有的值

items()
print(l1.items())
# dict_items([('name', 'jason'), ('pwd', 123), ('hobby', 'read')])
# 一次性获取字典的键值对数据 

用for循环也能获取字典的键值对数据,但远不如items()快捷
l1 = {'name': 'jason', 'pwd': 123, 'hobby': 'read'}
for i in l1.items():
    k, v = i
    print(k, v)
# name jason
# pwd 123
# hobby read

#6、补充
快速生成值相同的字典fromkeys()
当第二个公共值是可变类型的时候,通过任何一个键修改都会影响所有append()

6、元组

tuple()
支持for循环的数据类型都可以转成元组,元组的索引不会改变绑定的地址。

1、索引取值
l1 = (1,2,3,4,5)
print(l1[1])  # 输出结果:2

2、切片操作
L1 = (1,2,3,4,5,6,7,8)
print(L1[0:5])
# (1, 2, 3, 4, 5),索引切割0到4的数据值
print(L1[:])
# (1, 2, 3, 4, 5, 6, 7, 8),不写数字就默认都要,相当于[],输出L1所有的值


3、间隔、方向
L1 = (1,2,3,4,5,6,7,8)
print(L1[::-1])
# (8, 7, 6, 5, 4, 3, 2, 1) 从右往左取值(全部),[::-1]只说明方向未规定范围

4、统计元组内数据值的个数
len()
l1 = (1, 2, 3, 4, 5)
print(len(l1))  # 输出结果:5

5、统计元组内某个数据值出现的次数
count()
t1 = (11, 22, 33, 44, 55, 66)
print(t1.count(11))
# 1 ,11在t1里只出现了1次

6、统计元组内指定数据值的索引值
 t1 = (11, 22, 33, 44, 55, 66)
    print(t1.index(22))
# 1 ,在t1中索引,22在1的位置

7、集合

set()
集合内数据必须是不可变类型(整型、浮点型、字符串、元组)
集合内数据也是无序的,没有索引的概念
遇到去重和关系运算这两种需求的时候才应该考虑使用集合

#1、去重
集合直接打印就可以得到去重的结果,但无法保留原先数据的排列顺序。
l1 = {1, 2, 3, 3, 4, 3, 2, 3, 4, 1, 3, 4, 3, 4, 5, 5}
print(l1)  # 输出结果:{1, 2, 3, 4, 5}

#2、关系运算
s与l是两个账号,模拟这两个账号共同好友的情况

s = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
l = {'kermit', 'tony', 'gangdan'}
print(s & l)  # 两个的共同好友
print(s | l)  # 所有的名字
print(s - l)  # 第一组数据独有的名字
print(s ^ l)  # 在两组数据中没有同时出现的数据

#父集、子集
s = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
l = {'kevin', 'jason', 'gangdan'}
print(s > l)# true,s包含l,s是l的父集
print(s < l)# False,l不能包含s,l是s的子集
程序员灯塔
转载请注明原文链接:总结小计
喜欢 (0)
违法和不良信息举报电话:022-22558618 举报邮箱:dljd@tidljd.com