10.3学习归纳总结

1|010.3学习归纳总结

1|1一、python基本数据类型

1.整型（整数）
  应用场景：年级，班级人数，年份
  代码实现：
        age = 18
  表达关键字：int
2.浮点数（小数）
  应用场景：薪资，身高
  代码实现：
        height = 1.8
  表达关键字：float
3.字符串（文本）
  应用场景：姓名，爱好
  代码实现：
        name = 'jia'
  表达关键字：str
4.列表（存储多个数据值）
  代码实现：
       list = [11, 22, 33, 44]
  表达关键字：list
5.字典（能够精确地存储和表达数据的含义）
  代码实现：
       dict = {
           name = 'jia',
           age = 18
       }
        大括号括起来，内部存放数据，数据的形式是k:v键值对
  表达关键字：dict
6.布尔（用于判断事物的对错，是否可行，主要用于流程控制）
  状态：
       True:对的，可行的，真的
       False:错的，不可行的，假的
  Python中所有的数据自带布尔值：
       布尔值为False的数据：0,None,'',{},[]
       布尔值为True的数据：除了上面五个都是
  布尔值得变量的命名一般推荐以is开头：
    eg：
        is_right = True
        is_left = False
  表达关键字：bool
7.元组（也称'不可变列表'，数据地址不可变）
  代码实现：
        t1 = (1, 2, 3, 'jia')
  元组和列表的区别：
    1.元组的数据不能被改变
    2.列表使用的是[],元组使用的是()
    3.列表属于可变类型，元组是不可变类型
  表达关键字：tuple
  在使用存放多个数据的数据类型时，如果元组里面只有一个数据时，建议在数据值后面加个逗号
8.集合（用于去重和关系运算）
  去重：去除存放的数据
  关系运算：判断两个集合之间的数据值的关系
  大括号括起来，里面存放多个数据值，数据值之间用逗号隔开
  代码实现：
        s1 = {11, 22, 33, 44, 55}
  定义空集合：c = set()
  表达关键字：set

1|2二、用户交互

1|01.输入与输出

1.输入(input)  # 获取用户输入的信息
  eg：
    username = input('请输入您的用户名')
    print(username)
 '''
 1.先获取用户输入的信息
 2.再将数据赋值给左边的username
 3.通过username使用用户传入的数值
 4.input获取到的信息一般统一处理成字符串类型
 '''
2.输出(print)  
eg:
  print()  # 打印数据值
  print(name)   # 括号里面可以放数据值也可以放变量名
  print(s1, s2, s3)  # 括号里面可以放多个数据值或者变量名
 '''
 换行符：\r\n   \n   \r
 最早的换行符是：\r\n
 print可以切换换行符的
 不换行:print(数据，end='默认是\n')
 '''

1|02.python2与python3的区别

1.输入的区别
  python2:input输入字符串时要带上引号，输入数字时不需要，raw_input用来接收字符串的        
  python3:只有input,它返回的都是str类型
2.输出的区别
  python2: print 数据值 或者  print(数据值)
  python3: print(数据值)
3.字符串编码的改变
  python2: ASCII编码方式
  python3: UTF-8形式
4.内置函数的区别
  python2: range()内置函数直接生成列表(占用大量内存会死机)，xrange()只生成一个生成器
  python3: range()只生成一个生成器

1|3三、格式化输出

程序中想要占位就得用占位符
eg：
 info = 'xx女士，您好，您xx月的话费是xx,余额是xx'
方法1：
%s:支持所有的数据类型
'''
info = '%s女士，您好，您%s月的话费是%s,余额是%s'
print(info % ('王',3,300,400))
'''
方法2：
%d:支持数字占位
'''
info = '%d女士，您好，您%d月的话费是%d,余额是%d'
print(info % ('王',3,300,400))
'''

1|4四、多种赋值符

1.链式赋值
 eg:
     x = 1
     y = x
     z = y
     x = y = z = 1
2.解压赋值
 eg:
     num = [1, 2, 3, 4]
     num1, num2, num3, num4 = num
3.交叉赋值
 eg:
     x = 1
     y = 2
     temp = x
     x = y
     y = temp
     print(x,y)

1|5五、多种运算符

1|01.基本运算符

1.数学运算符
  加   +=   # x += 10  x = x + 10
  减   -=   # x -= 10  x = x - 10
  乘   *=   # x *= 10  x = x * 10
  除   /=   # x /= 10  x = x / 10
  取余  %=   # x % =10  x = x % 10
  幂   **=  # x ** = 10  x = x ** 10
2.比较运算符
  <  >   <=  >=  ==   !=

1|02.成员运算符

判断个体是否在群体里面
in  是否包含条件
not in  是否不包含条件
eg:
    name_list = ['jia', 'jason', 'tom']
    print('jia' in name_list)
    print('tia' not in name_list)

1|03.逻辑运算符

逻辑运算符与条件搭配着一起使用
1. and  与
 and连接的多个条件必须全部成立，结果才会成立
 如果and左边的条件是成立的，那么完全取决于右边的条件
 如果右边是数据值，那么结果就是数据值，如果是表达式，那么则为布尔值
2. or   或者
  or连接的多个数据值，只要有一个成立，结果就成立
  准确说出具体结果的方法和and差不多
3. not  非
   not  取反

1|04.身份运算符

id()  返回一串数字，可以查看内存地址
is    判断内存地址是否相同
==    判断数据值是否相同

1|6六、垃圾回收机制

1.垃圾回收机制
 专门回收不可用的变量值所占的内存空间，
2.为什么要用垃圾回收机制
  程序运行过程中会申请大量的内存空间，对于一些没有用的内存空间没有及时处理的话，会造成程序崩溃，内存溢出，为了更好的管理内存，则用解释器自带的垃圾回收机制，清理垃圾，释放内存。
3.垃圾回收机制的原理分析
   (1).引用计数
   (2).标记清除
   (3).分代回收

1|7七、流程控制

1|01.顺序结构

代码块从上往下依次执行

1|02.if分支结构

1.单if分支结构
 if 条件：
    条件成立才会执行的代码块
eg:
    username = input('username-->>')
    if username == 'jia':
        print('你好')  
2.if...else...分支结构
if 条件：
   条件成立之后执行的子代码
else:
    条件不成立执行的子代码
eg:
    username = input('username-->>')
    if username == 'jia'：
     	print('你好，jia')
    else:
        print('不好意思，认错了')
3.if...elif...else分支结构
 if 条件1:
    条件1成立之后执行的代码块
 elif 条件2：
 	条件1不成立，条件2成立执行的代码块
 elif 条件3：
 	条件1,条件2不成立，条件2成立执行的代码块
 else：
 	上述条件都不成立时，执行的代码块
注意：中间的elif可以写多个，都是子代码只会执行一个
eg:
    score = input('请输入你的成绩-->>')
    score = int(score)   # 讲字符串的整数转换成整型的整数
    if score >= 90:
        print('优秀')
     elif score >= 80:
        print('良好')
     elif score >= 70:
        print('一般')
     elif score >=60:
        print('及格')
     else:
        print('不及格')
4.if的嵌套使用
  eg:
    is_eat = True
    is_drink = True
    is_play = False
    if is_eat:
        print('吃了米饭')
        if is_drink:
            print('喝了八杯水')
            if is_play:
                print('玩了一下午')
            else:
                print('一直在学习')
        else:
            print('一天都没有喝水')
    else:
        print('什么都没吃')

1|03.while循环结构

循环结构就是让一些代码反复执行
while 条件:
    条件成立之后执行的子代码（循环体代码）
1.先判断条件是否成立，成立则执行代码体
2.循环体代码执行完毕，再回条件处判断，判断条件是否成立
3.如果成立，继续执行代码体
4.按照上面的次序，执行，直到条件不成立才会结束循环
eg:
    count = 1
    while count < 5:
        print('结束了')
         count += 1
     print('哈哈哈哈') 
额外知识点：
while 条件：
 	循环体代码
else：
	循环体没有强制被结束的情况下，执行完毕就会执行else子代码

1|04.for循环结构

1.for循环的主要应用场景：循环获取多个数据值
2.for循环语法结构：
    for 变量名 in 待遍历的数据：
         for循环体代码
  eg:
        info = 'hello word'
        for i in info:
            print(i)  # 打印出来十位字符，输出的是单个字符，空格也算单个字符
3.for循环特点：擅长遍历取值，不需要结束条件（遍历完自动结束）
4.for循环主要遍历的数据类型有（字符串，列表，元组，字典，集合）
5.for循环中如果执行到break也会直接结束整个循环的
6.for循环如果执行到continue也会结束当前循环开始下一次循环

1|05.流程控制的小知识点

1.python中使用代码的缩进来表示代码的从属关系
2.并不是所有代码都有子代码的
3.如果多行代码同属一个父代码，那么他们有相同的缩进量
4.某一行要写子代码的话，这一行的结尾一定要有冒号
5.缩进可以按空格键或者tab键

1|8八、数据类型的内置方法

1|01.内置方法

1.内置方法是每个数据类型自带的功能
2.Python中数据类型调用内置方法的统一句式：句点符(.)
  绑定的字符串变量名.字符串内置方法

1|02.整型相关操作

1.类型转换(把其他类型转换为整型)
 int(其他数据类型)
 浮点型可以直接转，字符串转的话内部必须满足是纯数字才可以
2.进制数的转换
  十进制转为其他进制
  print(bin(30))
  print(oct(20))
  print(hex(29))

1|03.浮点型相关操作

1.类型转换（把其他类型转换为浮点型）
  float(其他数据类型)
2.Python自身对于数字的敏感度较低
  需要更精确地计算就得借助于解释器模块numpy

1|04.字符串相关操作

# s1 = 'hello word'
1.类型转换
  str(其他数据类型)
2.索引取值
  起始位置为0，超出范围直接报错
3.切片操作
  print(s1[0])   # h
4.修改切片的方向（间隔）
  print(s1[2:3:-1])
5.统计字符串中字符的个数
  print(len(s1))
6.移除首尾字母的空格
  .strip()
7.切割字符串中指定的字符
  .split()
8.字符串格式化输出
  .format
9.字符串大小写
  .upper()  # 统一转为大写
  .lower()  # 统一转为小写
10.判断字符串中是否是纯数字
  .isdigit()
11.替换字符串中指定的内容
  .replace()
12.字符串的拼接
  .join()
13.统计字符出现的次数
  .count()
14.判断字符串的开头或者结尾
  startswith  开头
  endswith    结尾
15.title()  # 所有首字母大写
15.capitalize()  # 第一个首字母大写
15.swapcase()  # 大写变小写 小写变大写
15.index()  # 索引
15.find()  # 查找

1|05.列表相关操作

l1 = [11, 22, 33, 44, 55, 77]
1.索引取值
  print(l1[-1])   # 77
2.切片操作
  print(l1[0:5])  # [11, 22, 33, 44, 55]
3.间隔数
   print(l1[::-1])   # [77, 55, 44, 33, 22, 11]
4.统计列表中的数据值个数
  eg:
      print(len(l1))   # 6
5.数据值修改
  eg：
        l1[0] = 99
        print(l1)     # [99, 22, 33, 44, 55, 77]
 6.列表中添加数据值
    (1).append()   # 尾部追加数据值
    	eg: l1.append('数据')
    (2).insert()   # 任意位置插入数据值
    	eg: l1.insert(1, [11, 33])
    (3)+号        # 扩展列表 合并列表
    	eg: 
            l2 = [2, 4]  
            print(l1 + l2)  # [11, 22, 33, 44, 55, 77, 2, 4]
    (4).extend()   # 相当于for循环加append
        eg:  
            l1.extend(l2)  
            print(l1)  # [11, 22, 33, 44, 55, 77, 2, 4]
         相当于：
           for i in l2:
                l1.append(l2)
            print(l1)
7.删除列表数据
    (1)del  通用删除关键字del
        eg: 
            del l1[0]   
            print(l1)
    (2) remove  彻底删除数据值
         eg：
             l1.remove(22)
             print(l1)
    (3)pop  尾部弹出数据值，并没有真正删除数据
         eg:
             l1.pop(33)
             print(l1)
8.排序
     (1) .sort()就是升序
       eg:
        s1 = [33, 44, 66, 88, 21, 12]
        s1.sort()
        print(s1)    # [12, 21, 33, 44, 66, 88]
    (2) 降序  加一个参数，将其设为True,就是降序了
       eg:
        s1 = [33, 44, 66, 88, 21, 12]
        s1.sort(reverse=True)
        print(s1)     # [88, 66, 44, 33, 21, 12]
9. 统计列表中某个数据出现的次数
    eg:
      print(l1.count(22))
10.颠倒列表顺序
   eg:
      l1.reverse()
      print(l1)

1|06.字典相关操作

dict()
eg:
    user_dict = {
    'username': 'jason',
    'password': 123,
    'hobby': ['read', 'music', 'run']
}
1.按k取值
  print(user_dict['username'])   # jason
2.按内置方法get取值
  print(user_dict.get('username'))   # jason
3.修改值数据
  user_dict['usernam'] = 'tony'   # 键存在则修改对应的值
4.新增键值对
  user_dict['age'] = 18
5.删除数据
  del user_dict['username']
6.统计字典中键值对的个数
  print(len(user_dict))  # 3
7.字典三剑客
  print(user_dict.keys())   # 一次性获取字典所有的键
  print(user_dict.values())  # 一次性获取字典所有的值
  print(user_dict.items())   # 一次性获取字典的键值对数据

1|07.元组相关操作

tuple()
支持for循环的数据类型都可以转换为元组
l1 = (11, 22, 33, 44, 55, 66)
1.索引取值
 print(l1[2])   # 33
2.切片
 print(l1[2:4])  # (33, 44)
3.间隔，步长
 print(l1[0:5:2])  # (11, 33, 55)
4.统计元组内某个数据值出现的个数
 print(len(l1))    # 6
5.统计元组内某个数据值出现的次数
 print(l1.count(22))    # 1
6.统计元组内指定数据值的索引值
 print(l1.index(22))  # 1
7.元组内如果只有一个数据值那么逗号不能少
8.元组内索引绑定的内存地址不能被修改（可变数据类型内存地址不变的）
  可变数据类型有：集合，列表，字典
9.元组不能新增或者删除数据

1|08.集合相关操作

set()
集合内的数据必须是不可变类型（整型，浮点型，字符串，元组）
集合内数据是无序的 没有索引的概念
1.去重
  去除集合内重复的数据值
eg:
    l2 = {11, 33, 44, 88, 99}
    l1 = set(l2)
    l2 = list(l1)
    print(l2)      # [33, 99, 88, 11, 44]
2.关系运算
&    共同的部分
-    独有的部分
|    全部的部分（和）
^    独有部分的和

__EOF__

本文作者：泡芙有点甜
本文链接：https://www.cnblogs.com/zx0524/p/16757863.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！