python基本数据类型以及基础运算符

今日分享内容

• 作业讲解
• python基本数据类型
• 与用户交互
• 格式化输出
• 基本运算符
• 多种赋值方式
• 逻辑运算符
• 成员运算符

分享内容详细

# 附加练习题(提示:一步步拆解)
# 1.想办法打印出jason
L1 = [11, 
      22, 
      'kevin', 
      ['tony', 
       'jerry', 
       [123, 
        456, 
        'jason']
       ]
      ]
'''分步操作'''
# 1.先看大列表到底有几个数据值 以及我们想要的数据值在哪个里面
# print(l1[3])
L2 = L1[3]  # ['tony', 'jerry', [123, 456, 'jason']]
# 2.再次思考小列表有几个数据值 以及我们想要的数据值在哪个里面
# print(l2[2])
L3 = L2[2]  # [123, 456, 'jason']
# 3.最后转化成了简单的索引直接取值
print(l3[2])
'''简化操作'''
print(l1[3][2][2])

# 2.想办法打印出大宝贝
d1 = {'name': 'jason', 
      'others': {'a1': 'heiheihei', 
                 'a2': {'k1': 'hahaha', 
                        'k2': 'hehehe', 
                        'k3': '大宝贝'}
                 }
      }
'''分步操作'''
# 1.先拿大字典第二个键值对的值
# print(d1['others'])
d2 = d1['others']  # {'a1': 'heiheihei', 'a2': {'k1': 'hahaha', 'k2': 'hehehe', 'k3': '大宝贝'}}
# 2.再拿小字典第二个键值对的值
# print(d2['a2'])
d3 = d2['a2']
# 3.转化成简单的按k直接取值
print(d3['k3'])
'''简化操作'''
print(d1['others']['a2']['k3'])

# 3.想办法打印出run
data = {'username': 'jason', 
        'hobby': [11,
                  22, 
                  {'height': 183, 
                   'hobby': ['read', 
                             'run', 
                             'music'
                             ]
                   }
                  ]
        }
'''分步操作'''
# print(data['hobby'])
data1 = data['hobby']  # [11, 22, {'height': 183, 'hobby': ['read', 'run', 'music']}]
# print(data1[2])
data2 = data1[2]  # {'height': 183, 'hobby': ['read', 'run', 'music']}
# print(data2['hobby'])
data3 = data2['hobby']
print(data3[1])
'''简化操作'''
print(data['hobby'][2]['hobby'][1])

基本数据类型之布尔值bool

 1. 用来判断事物的对错 是否可行 主要用于流程控制中
 2. 只有两种状态
    True  对的 真的 可行的
    False 错的 假的 不可行的
 3. python中所有数据都自带布尔值
    布尔值为False的数据：
    0 None '' [] {}
    布尔值为True的数据：
    除了上面 都是True
 4.存储布尔值的变量名一般推荐使用is开头
    is_delete = False
    is_alive = True

很多程序中提供的注销账户的功能 其实底层并没有删除数据 而是修改了数据的状态

id	username	password	phone	is_delete
1	jason	123	110	1
2	kevin	321	110	0

基本数据类型之元组tuple

 1.也称为'不可变'的列表
   元组内索引绑定的内存地址不能修改
 2.小括号括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 数据值可以是任何数据类型
 3.代码实现
  t1 = (11, 22, 'jason')
 4.元组与列表的对比
   l1 = [11, 22, 33]
   print(l1[2])  # 获取索引2对应的数据值
   l1[2] = 666
   print(l1[2])  # [11, 22, 666]
   
   # t1 = (11, 22, 33)
   # print(t1[2])
   # t1[2] = 999
   # print(t1[2])    # 直接报错
   
 5.元组内如果只有一个数据值
	t1 = (1)
    t2 = (11.11)
    t3 = ('jason')
    print(type(t1), type(t2), type(t3))  # <class 'int'> <class 'float'> <class 'str'>
    t1 = (1,)
    t2 = (11.11,)
    t3 = ('jason',)
    print(type(t1), type(t2), type(t3))  # <class 'tuple'> <class 'tuple'> <class 'tuple'>
    """
    建议:以后在使用可以存放多个数据值的数据类型时 如果里面暂时只有一个数据值 那么也建议你加上逗号
    """  

基本数据类型之集合set

1.集合只能用于去重和关系运算
 
2.集合内数据只能是不可变类型
 
3.大括号括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 数据值不是k:v键值对
4.代码实现
	s1 = {1, 2, 3, 4, 5, 6}
5.定义空集合与空字典	
	{}  	默认是字典
 	set()	定义空集合

与用户交互

"""
   以前打车
	师傅：哪里
	你：朝天门
	师傅：到站 100元
	...
    随后应用程序代替了师傅跟我们交互
    各个打车平台
"""
1.获取用户输入
	 input
	 # 获取用户输入
    username = input('请输入您的用户名>>>:')
    """
    1.先执行input获取用户输入
    2.将输入的数据绑定给变量名username
    3.以后在程序中就可以使用变量名反复调用用户数据
    """
	强调:input获取到的数据都会统一处理成字符串类型
2.输出内部信息
	print
 	1.括号内既可以放数据值也可以放变量名 并且支持多个 逗号隔开即可
 	2.print自带换行符
		换行符:\r\n \n(斜杠与字母组合到一起可能会产生特殊的含义)
	3.print也可以切换结束符
    	print(数据,end='默认是\n')
扩展:python2与python3中两个关键字的区别
 	python2中
    	input方法需要用户自己提前指定数据类型 写什么类型就是什么类型
 	 	 raw_input方法与python3中input一致 输入的统一处理成字符串	
	python2中
    	print方法有两种使用方式
        	print 数据值
           print(数据值)

格式化输出

提前定义好一些内容 将来需要使用的时候可以局部修改
	eg:奖状、录取通知书、合同
代码实现
	在现实生活中大部分情况下使用下划线提示别人填写内容
 	但是在程序中需要使用占位符:%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
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.比较运算符
	< > <= >= ==(等于号) !=(不等于)

常用赋值符

1.链式赋值
	 # name = 'jason'
    # name1 = name
    # name2 = name
    # 链式赋值
    name = name1 = name2 = 'jason'
2.交叉赋值
	 m = 100
    n = 999
    '''让m和n互相转换绑定的值'''
    """奇葩式写法"""
    # m = n
    # n = m
    # print(m, n)  # 999 999
    '''方式1:采用中间变量'''
    # temp = m
    # m = n
    # n = temp
    # print(m, n)  # 999 100
    '''方式2:交叉赋值语法'''
    m, n = n, m
    print(m, n)  # 999 100
3.解压赋值
	 name_list = ['jason', 'kevin', 'tony', 'oscar']
    '''低端的写法'''
    # name1 = name_list[0]
    # name2 = name_list[1]
    # name3 = name_list[2]
    # name4 = name_list[3]
    '''解压赋值语法'''
    # name1, name2, name3, name4 = name_list
    '''解压赋值在使用的时候 正常情况下需要保证左边的变量名与右边的数据值个数一致'''
    # a, b = name_list  # 变量名少了不行
    # a, b, c, d, e = name_list  # 变量名多了也不行
    '''当需要解压的数据个数特别多 并且我们只需要使用其中的几个 那么可以打破上述的规则'''
    # a, *b = name_list  # *会自动接收多余的数据 组织成列表赋值给后面的变量名
    # print(a)  # jason
    # print(b)  # ['kevin', 'tony', 'oscar']
    # a, c, *b = name_list
    # print(a)
    # print(c)
    # print(b)  # ['tony', 'oscar']
    # a, *b, c = name_list
    # print(a)  # jason
    # print(b)  # ['kevin', 'tony']
    # print(c)  # oscar
    '''当数据值不准备使用的时候 可以使用下划线作为变量名绑定'''
    a, *_, c = name_list

逻辑运算符

'''主要配合条件一起使用'''
    and	   与
    and连接的多个条件必须全部成立 结果才成立
    你要去NBA打球：
    你必须190cm，必须要运球好，必须要意识好，必须要投篮准，必须要身体素质好...
    face = 99   # 吴彦祖的颜值
    face2 = 999999999  # 哥的颜值
    180 > 190 and Face2 > face and 10 < 1 and 1 == 2  
    如果条件中全部由and组成那么判断起来非常的简单 只要发现一个不成立 结果就不成立
    print(1 < 10 and 666)  # 666  成立
    print(1 < 10 and 2 < 8)  # True  成立
    print(111 and 222)  # 222  成立
    如果需要你准确的说出具体的结果值  那么需要按照下列方式
    如果and左边的条件是成立的 那么就完全取决于右边的条件
    右边如果直接是数据值 那么结果就是该数据值 如果是含有表达式 则为布尔值
 
        or 或
    or连接的多个条件只要有一个成立 结果就成立
    wei:你去相亲提要求:要么家里有钱 或者家里有钞票 或者家里有美元 或者家里有黄金  
    有钱 or 有钞票 or 家里有美元 or 黄金
    1 > 2 or 4 < 8 or 10 < 1 or 1 == 2  
    如果条件中全部由or组成那么判断起来非常的简单 只要发现一个成立 结果就成立   
    # print(1 < 10 or 666)  # True
    # print(666 or 1 > 10)  # 666
    print(0 or False)  # False
    print(0 or 111)  # 111
    规律用and
 
     not  非
    取反
    类似于说反话
 
"""
三者混合使用的时候有优先级之分 但是我们不需要记忆优先级 应该通过代码的形式提前规定好优先级
   eg: 先乘除有加减  但是可以使用括号来改变优先级
	(3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3)
"""

成员运算符

判断个体在不在群体内
 
# name_list = ['张翰', '科比', 'jack', '啊峰']
# print('tony' in name_list)  # False
# print('tony' not in name_list)  # True
# print('j' in name_list)  # False 列表最小单位是数据值  不能再细分
 
# s1 = 'hello world'
# print('d' in s1)  # 字符串最小单位是单个单个的字符
 
d1 = {
      'username': 'jason',
      'pwd': 123
}
print('jason' in d1)  # False 字典成员运算只有键参与
print('username' in d1)  # True      'username' 'pwd'

身份运算符

"""
id()  返回一串数字 该数字可以看成是内存地址
"""
is     判断内存地址是否相同
==     判断数据值是否相同
 
# l1 = [11, 22, 33, 44, 55, 66, 77, 88]
# l2 = [11, 22, 33, 44, 55, 66, 77, 88]
# print(l1 == l2)  # True
# print(id(l1))
# print(id(l2))
# print(l1 is l2)  # False
 
# 小整数池
i1 = 11
i2 = 11
print(i1 is i2)
 
 
s1 = 'jason jason jason'
s2 = 'jason jason jason'
print(s1 is s2)
不同的环境下可能优化的程度不一样 

值相同 内存地址可能不同
内存地址相同 值肯定相同

Name = input('请输入你的名字>>>=')
Age = input('请输入你的年龄>>>=')
Sex = input('请输入你的性别>>>=')
Job = input('你的职业是什么>>>=')
 
print('-------------info of jason-------------')
print('Name', Name)
print('Age', Age)
print('Sex', Sex)
print('Job', Job)
print('--------------end-----------------')
 
 
v1 = 1 or 3  # 发现第一个成立 直接成立
v2 = 1 and 3  # 1代表True 3也代表True 两者都成立 输出后者
v3 = 0 and 2 and 1  # 0代表False  and连接的多个条件必须全部成立 结果才成立 输出结果为 0
v4 = 0 and 2 or 1  # 0代表False  and连接的多个条件必须全部成立  运算完 0和2之后 再运算0和1 or连接的多个条件只要有一个成立 结果就成立 输出1
v5 = 0 and 2 or 1 or 4  # 0 and 2 输出 0  0 or 1 or 4  0代表False 1 or 4 都成立 碰到第一个 直接输出 1 
v6 = 0 or False and 1  # 0 of False 都不成立  False and 1  有false 不成立 所以输出 false
print(v1, v2, v3, v4, v5, v6)