python基础

print("今天天气真好")  # 这行代码的作用是：在屏幕上显示“今天天气真好”

买牛奶  # 记得买低脂的

"""
下面这段代码的作用：
1. 记录今天吃了什么
2. 统计一共吃了几种食物
"""
food = ["苹果", "米饭", "牛肉"]
print("今天吃了", len(food), "种食物")

【周末计划】
- 上午：去公园跑步
- 下午：看电影
- 晚上：做饭

age = 18  # 变量名为age，存放的数据是18（整数）
name = "小明"  # 变量名为name，存放的数据是"小明"（字符串，用引号包裹）
height = 1.75  # 变量名为height，存放的数据是1.75（浮点数/小数）

零花钱 = 100元  
姓名 = "小明"  
身高 = 1.75米

age = 18  
Age = 20  
print(age)  # 输出18（不是20）

money = 100  # 一开始有100元  
money = 200  # 现在把钱改成200元（覆盖旧值）  
print(money)  # 输出200（不是100）

count = 0  
count = count + 1  # 把count原来的值（0）加1，再存回count  
print(count)  # 输出1（相当于“计数器+1”）

x = 10  
print(type(x))  # 输出 <class 'int'>（表示x是整数类型）

# 定义字符串
strings = '人生苦短，我用python！'
strings2 = "人生苦短，我用python！"
strings3 = '''人生苦短，
                我用python！'''
strings4 = """人生苦短，
                我用python！"""

# 打印输出
print(strings, strings2, strings3, strings4)
print(id(strings), id(strings2), id(strings3), id(strings4))
print(type(strings), type(strings2), type(strings3), type(strings4))

# 需要注意的情况，就是字符串内外都含引号的时候（字符串本身就是带引号）  人生苦短，我用'python'！
# print('人生苦短，我用'python'！')
# strings5 = '人生苦短，我用'python'！'
# strings5 = "人生苦短，我用'python'！"
print("人生苦短，我用'python'！")

# 字符串的拼接  "人生苦短"  "我用'python'！"
print("人生苦短" + "我用'python'！")
print("5" + "20")
print("人生苦短" * 10)
print("人生苦短" + "人生苦短" + "人生苦短" + "人生苦短" + "人生苦短" + "人生苦短" + "人生苦短")

# 字符串的索引
strings6 = 'abcde'
# 索引       0 1 2 3 4   索引 从0开始
#            -5  -4 -3 -2 -1

print(strings6[0])
print(strings6[1])
print(strings6[2])
print(strings6[3])
print(strings6[4])

print("-----------------------")
print(strings6[-1])
print(strings6[-2])
print(strings6[-3])
print(strings6[-4])
print(strings6[-5])

# 捕获异常机制
try:
    strings6[0] = 'q'
except Exception as e:
    print(e)

# %s
name = input('请输入您的名字:')
# 一个值的话直接放到%后面
# %s 占位符
print("My name is xxx，my age is %s" % name)

# %d/%i
# 多个值的话直接放到%后面,要括号
age = input('请输入您的年龄:')
print("My name is %s, my age is %d" % (name, int(age)))  # 注意类型转换
print("My name is %s, my age is %i" % (name, int(age)))  # 注意类型转换

# %f 占位符默认显示 6位小数
print("小数 %f" % 1.0001)
# 需要调整小数位数，可通过 %.nf 格式指定（n 为数字），例如 %.2f 显示2位小数。
print("指定小数位: %.2f" % 1.0001)

# 1、索引取值
msg = '人生苦短 我用python'
print(msg[0])

# 2、切片（顾头不顾尾）（左闭右开区间）查找字符串当中一段值   [起始值:终止值:步长] 索引值
# 步长：默认为1，此时可以省略，用于控制提取字符的间隔  不能为0
# 切黄瓜 一节一节
print(msg[0:5])
print(msg[0:5:1])
print(msg[0:5:2])
# 提取不会改变原值
print(msg)

# 如果省略起始值，默认字符串开头（索引0）开始
# 如果省略终止值，默认到字符串末尾结束
# 如果省略步长，默认步长为1 为正数  从左往右取
print(msg[::])
print(msg[0::])
print(msg[0::2])

# 步长是负数  # 从右向左提取字符，反向提取
# msg = 'hello world'
print(msg[::-1])
print(msg[10::-1])
print('-------------')
print(msg[10:5:-1])
print(msg[5:10:-1]) # 取不到值，没有值
print(type(msg[5:10:-1])) # 空字符串

#3、长度len方法 可以计算长度
print(len(msg))

# 4、成员运算  in 和 not in： 判断子字符串是否存在于另一个大的字符串中
# 返回类型 布尔 True False
print('linmo' in 'linmo is dsb')
print('xialuo' not in 'linmo is dsb')

# 增
# 字符串拼接
print('linmo'+'dsb')

# join
str1 = '真正的勇士'
str2 = '敢于直面惨淡的人生'
str3 = '敢于正视淋漓的鲜血'
# 可以把列表的元素组合成字符串
print(''.join([str1,str2,str3]))
print('，'.join([str1,str2,str3]))
print('哇塞'.join([str1,str2,str3]))
# 空格也属于字符
print('   '.join([str1,str2,str3]))

# 删
name1 = 'dahai'
del name1
print(name1)

# 改   字符串底层是不可变的数据类型，直观体现不能通过索引直接改里面字符的值， 但可以间接修改（比如说替换）
# 1、字符串字母变大写和变成小写 lower，upper
msg1 = 'abc'
msg2 = msg1.upper() # 变大写
# 原值
print(msg1)
print(msg2)
print(id(msg1))
print(id(msg2))
# 注意字符串进行改变需要重新赋值，所以它也是不可变类型，它的原值的变量不会变，
# 只是做了一个方法改变了它的值，但是这个值并不是在原来的基础上改的，而是重新赋值给一个新的变量

# 2、把第一个字母转换成大写 capitalize
lettter = 'abcd'
print(lettter.capitalize())
# 3、每个单词的首字母进行大写转换 title
letter_msg = 'hello world'
print(letter_msg.title())

# 4、把字符串切分成列表  split 默认空格字符切分
msgg = 'hello world python'
# 默认以空格切分
print(msgg.split())
# 可以切分你想要的字符 比如*
msgg1 = 'hello*world*python'
print(msgg1.split('*'))
#切分split的作用:针对按照某种分隔符组织的字符串，可以用split将其切分成列表，进而进行取值
msggg = 'root:123456'
print(msggg[0:4])
print(msggg.split(':')[0])
print(msggg.split(':')[1])

#5、去掉字符串左右两边的字符 strip 不写默认是空格字符，不管中间的其他的字符
user = '       dahai    '
print(user)
print(user.strip())
# name = input('请输入用户名').strip()
# print(name)

# 字符串的替换 replace()
# 1、基本替换
s = 'Hello World!'
new_s = s.replace('Hello','Hi')
print(new_s)
# 2、替换所有匹配的字符串
s = '不吃香菜  真爱粉  不吃香菜  两年半'
# 将所有'不吃香菜'替换成'个人练习生'
new_s = s.replace('不吃香菜', '个人练习生')
print(new_s)
# 3、指定替换次数
s = 'apple banana apple cherry apple'
# 只替换前两个'apple'
new_s = s.replace('apple','orange',2)
print(new_s)
# 4、替换空字符串
s = 'Hello, World!'
# 删除所有逗号
new_s = s.replace(',','')
print(new_s)

# 了解
# center,ljust,rjust 多余添加自己想要的字符 l ->left左 r ->right右
print('dahai'.center(11,'a')) # 总共有11个字符       -> 11字符
print('dahai'.ljust(11,'*'))  # 留左填右
print('dahai'.rjust(11,'*'))  # 留右填左

# 查
#1、find,index
# 查找子字符串在大字符串的哪个位置（起始索引）
msga = 'hello dahai is dsb dahai'
print(msga.find('dahai')) # 索引值
# 没找到会返回-1
print(msga.find('ddddd'))
print(msga.index('dahai'))
# 没找到会报错
# print(msga.index('ddddd'))
# 统计一个子字符串在大字符串中出现的次数 count
print(msga.count('dahai'))

# 判断一个字符串里的数据是不是都是数字 isdigit # 返回布尔值     判断什么      是不是   对不对   is开头的方法，就是判断
num = '1818'
num1 = '18aaa18'
aaaa = 'aaa'
print(num.isdigit())
print(num1.isdigit())

# 判断每个元素是不是都是字母 isalpha
print(aaaa.isalpha())
print(num.isalpha())
print(num1.isalpha())

# 比较开头的元素是否相同 startswith  以什么开头
# 比较结尾的元素是否相同 endswith    以什么结尾
# 返回布尔类型
mm = 'dahai xialuo'
print(mm.startswith('dahai'))
print(mm.endswith('uo'))
# 判断字符串中的值是否全是小写的 islower
# 判断字符串中的值是否全是大写的 isupper
letter2 = 'ABC'
letter3 = 'abc'
letter4 = 'aAbc'
print(letter2.isupper())
print(letter3.isupper())
print(letter4.isupper())
print(letter2.islower())
print(letter3.islower())
print(letter4.islower())

# 字符串的转义
# 字符串的转义   加了 \  字符不再表示它本身的含义
# 常用的  \n  \t
# \n 换行符
print('hello \n python')
# \n 横向换行符 相当于一个tab  四个空格
print('hello \t python')

# #（实在想打出\n \t）不让它转义
print(r'hello \n python \t')
# 实在想打出\n \t
print('hello \\n python \\t')

# 定义
age = 22
print(type(age))

# 定义
weight = 151.2
print(type(weight))
float_1 = 1.1
float_2 = 2.2
print(float_1 + float_2, "----")  # 结果不精确

x = 2 - 2j
print(x)
print(type(x))

# 基本的运算
"""
+ - * **
"""
num1 = 10
num2 = 3
print(num1 + num2)
print(num1 - num2)
print(num1 * num2)
print(num1 ** num2)  # num1的num2次方  10 的 3 次方

"""
 / // % 
"""
# // 是向下取整   地板除
print(num1 / num2)
print(num1 // num2)
print(15 / 4)
print(15 // 4)
# / 结果一定是浮点数
print(10 / 5)

# % 顾名思义就是求余数   被除数 / 除数 = 商 …… 余数
print(num1 % num2)

# 比较运算 > < >= <= == != 结果是布尔值  True False（比较值）
print(3 > 4)
print(3 < 4)
print(3 >= 4)
print(3 <= 4)
print(3 == 4)
print(3 != 4)
print(type(3 != 4))

# 身份运算符 判断是不是一个对象
a = 100000
b = 100000
print(id(a), id(b))  # 实际上a 和 b 是同时指向了10000
print(a is b)
print(id(100000), id(100000))
# 总结：
# 注意⚠️：在交互模式下，是不一样的（python有一个小整数池[-5,256]是一样的，超出范围不一样）(研究发现，程序中 -5 到 256 的整数出现频率最高)
# 特殊情况：同一代码块的大整数优化
# 在 同一代码块（如脚本文件、函数）中，相同的大整数字面量可能被编译器优化为同一对象（非小整数池机制，而是“常量折叠”）

#避免 == 与 is 混淆
#== 判断值相等（True == 1 为 True）。
#is 判断对象身份（True is 1 为 False，True 和 False 是单例对象）。

"""
3、赋值运算 =>  赋值 + 算术运算
    # 普通赋值 =
    # 加法赋值 +=
    # 减法赋值 -=
    # 乘法赋值 *=
    # 除法赋值 /=
    # 取余赋值 %=
    # 乘方赋值 **=
    # 整除(地板除)赋值 //=
"""
# 普通赋值 = (变量赋值)
num = 1

# 加法赋值 +=
num += 1  # num = num + 1
print(num)

# 减法赋值 -=
num -= 1 # num = num - 1
print(num)

# 乘法赋值 *=
num *= 2 # num = num * 2
print(num)

# 除法赋值 /=
num /= 2 # num = num / 2
print(num)

# 取余赋值 %=
num %= 2 # num = num % 2
print(num)

# 乘方赋值 **=
num **= 2 # num = num ** 2
print(num)

# 整除(地板除)赋值 //=
num //= 2 # num = num // 2
print(num)

flag1 = True
flag2 = False
print(flag1, type(flag1))
print(flag2, type(flag2))
flag1 = False
print(flag1)

# 我们定义一个变量表示一个人是否成年，然后我们再根据这个变量的值来执行不同的代码快
is_adult = input("请输入是否成年（成年输入1，未成年输入0）：")
print(is_adult, type(is_adult))

if is_adult == '1':
    is_adult = True
else:
    is_adult = False

if is_adult:
    print("这个人已经成年了！")
else:
    print("这个人还未成年！")

# 结果均为True，说明True和False的值就是1和0
print(True == 1)
print(False == 0)
# 均为False，说明True并不是1，False并不是0，只是值相等（可能会有语法警告）
print(True is 1)
print(False is 0)
# 1 和 1 是一个东西，但是 True 和 1 就不是一个东西 
print(1 is 1)
print(0 is 0)
# 说明不是一个东西，地址不一样
print(id(True), id(False))
print(id(1), id(0))

"""
# 重点知识
    # 不仅仅是真假  还有数据的有无
    # Python 数据"自带布尔值"：
    # 每个对象在条件判断中会根据自身状态（是否为空、是否为零等）自动转换为 True 或 False
        # None 表示"无值"或"不存在"，是 Python 中一个特殊的常量，属于 NoneType 类型（该类型只有 None 一个实例）。
        # 0  -> 0 == False
        # 空序列（容器）-->(空字符串、空列表、空字典、空集合、空元组)

# 布尔值为False所有"空"对象在布尔上下文中（如 if 条件判断）会被视为 False，非空对象则视为 True
"""
# if []: # 空列表
# if (): # 空元组
# if {}:  # 表示空字典（直接花括号会默认识别成空字典，不会识别成集合） print(type({}))
# if set():  # 空集合
# if '':  # 空字符串
# if 0:  # 0
if None: # None
    print(1)
else:
    print(2)

# 表示空字典（直接花括号会默认识别成空字典，不会识别成集合） print(type({}))
print(type({}))

lst = ["小明", 1, 1.1, True, ["小明", 1, 1.1, True]]
# 索引   0     1   2    3             4

print(lst[0], lst[-5])
print(lst[1], lst[-4])
print(lst[2], lst[-3])
print(lst[3], lst[-2])
print(lst[4], lst[-1])

# 取列表里面的列表的值
print(lst[4][0])

# 第4号索引的值整体赋值给变量 lst1
lst1 = lst[4]
print(type(lst1))
print(lst1[0])

# 修改某个位置上的值
try:
    lst[1] = '小红'
except Exception as e:
    print(e)
print(lst)

lst = ["小明", 1, 1.1, True, ["小明", 1, 1.1, True]]
# 索引    0    1   2    3             4
# 索引(反)-5   -4  -3   -2             -1
# 增删改查 统计
# 1、增
print("----------------增---------------")
# append(元素)
# 往列表末尾追加一个元素
lst.append("append")
print(lst)

# extend()
# 往列表当中添加多个元素 括号里放列表 也是末尾追加
lst2 = ["extend1","extend2"]
lst.extend(lst2)
print(lst)

# insert(索引,元素)
# 往指定索引位置前插入一个元素
lst.insert(1,'insert')
print(lst)

# 删
print("----------------删---------------")
# del
# del lst[0]
# print(lst)

# 指定删除
# lst.remove("小明")
# print(lst)

# pop  从列表里拿走一个值
# 按照索引删除值
print("---------------pop-------------")
# ·默认删除最后一个   pop返回值是删除的值
# lst.pop()
# print(lst)
# 指定索引
# lst.pop(0)
# print(lst)

# 清空列表
# lst.clear()
# print(lst)

# 改
print("----------------改---------------")
# 索引赋值
lst[0] = '小红'
print(lst)

# 切片赋值
# lst[0:2] = [1,2]
# print(lst)

# 反序
lst.reverse()
print(lst)

# 查
print("----------------查---------------")
# 索引取值 （正向取、反向取）
print(lst[0], lst[-9])
# 切片 [起始值:终止值:步长] 左闭右开
print(lst[::])
print(lst[3:0:-1])  # 取得到
print(lst[3:0:1])  # 取不到空置

# 统计
print("----------------统计---------------")
# len() 长度
print(lst, len(lst))
# index 查找元素索引
print(lst.index("小红"))
# print(lst.index("小"))  # 报错
# 统计元素出现次数：count()
lst3 = [1,1,3,4,1,2,1]
print(lst3.count(1))

t = (1, 1.1, '人生苦短，我用python！', True, (1, 1.1, '人生苦短，我用python！'), ['人生苦短，我用python！', 2, 3])
#    0   1            2               3                4                            5
#   -6  -5           -4              -3               -2                           -1
print(t, type(t))
print(t[0], t[-6])
print(t[1], t[-5])
print(t[2], t[-4])
print(t[3], t[-3])
print(t[4], t[-2])
print(t[5], t[-1])

print(t[4][0])
print(t[5][0])

t = (1, 2, '人生苦短', (4, 5), [7, 8])
#    0  1        2      3       4
#   -5 -4       -3     -2      -1

# 不能索引修改
# 元组本身是不可变的，他的元素是不能直接修改的，
# 但是如果元组里的元素本身就是可变的，那么这个可变的元素，它遵循的是自己可变的原则
try:
    t[0] = 2
except Exception as e:
    print(e)

# 元组里的列表可以改
t[4][0] = '小花'
print(t)

# 查
# 与列表一样索引，切片，长度len，count个数，index查找元素所在索引成员运算

# 删
del t

鱼:   带鱼、鲫鱼、鲤鱼
游戏: csgo、英雄联盟、cf、王者荣耀
key : value   --> 键值对

dic = {
    "列表": ["苹果", "香蕉"],  # 值可以是任何类型，比如列表
    "字符串": "饼干",  # 也可以是字符串
    "整型": 3,  # 值也可以是整型
    "布尔": True, # 值也可以是布尔
    "元组": (1,2,3), # 值也可以是元组
    "字典": {"小明": 18},  # 值也可以是字典
    "浮点": 1.1  # 值也可以是浮点
}

print(dic)
print(type(dic))
# 取值
print(dic['列表'])
print(dic['字符串'])
print(dic['整型'])
print(dic['字符串'])
print(dic['布尔'])
print(dic['元组'])
print(dic['字典'])
print(dic['浮点'])

# 字典的创建
# 花括号{}
info1 = {"name": '大海', 'age': 18}
# dict()
info2 = dict(x=1,y=2)
print(info1, id(info1))
print(info2, id(info2))

# 增
info1["addr"] = '北京'
info2["addr"] = '纽约'
print(info1, id(info1))
print(info2, id(info2))
# 对比id值可以发现增加之后不会改变内存地址，所以是可变类型

# len() 字典里面的len方法是查看键值对的个数
print(len(info1), len(info2))

# 成员运算  in 和 not in 字典的成员运算判断的是key，返回值是布尔值
print('name' in info1)
print('addr' in info2)

# 删
# clear()
# info1.clear()
# info2.clear()
# print(info1, info2)

# del
# del info1['addr']
# del info2['addr']
# print(info1, info2)

# 删除的key不存在会报错
# del info1['add']
# print(info1)

# pop 删除 返回值是value   实际上就是拿走了字典的value
# res = info1.pop('name')
# print(res, info1)

# 改
# 1'
# info1['name'] = "小海"
# print(info1)
# 2'
info1.update({"name": '小海'})
info1.update({"name1": '小海1'})  # 如果修改的字段不存在，其实就是新增了
print(info1)
# setdefault
# 有则不动/返回原值,无则添加/返回新值
# 字典中已经存在key则不修改,返回已经存在的key对应的value
res = info1.setdefault('name', 'xxx')
print(res, '-')
print(info1)
res2 = info1.setdefault('name2', 'xxx')
print(res2)
print(info1)

# 查
# 1'
print(info2['addr'])
# 查一个不存在的key会报错
# print(info1['xxx'])

# 2'
print(info1.get('name'))
# 没有key就返回None，不会报错
print(info1.get('xxxx'))
# 可自定义返回值
print(info1.get('xxxx', '无'))

# 3'
# 取所有key
print(list(info1.keys()))
# 取出所有值
print(list(info1.values()))
# 取出所有键值对
print(list(info1.items()))

# 集合的定义
s = {1,2,'人生苦短'}
# s = set()
print(s, type(s))

s1 = {'a','b','d'}
s2 = {'a','b','c'}
print(s1, type(s1))
print(s2, type(s2))

# 运算 交集 并集 差集 对称差集  想象你有两个朋友圈。
print(s1 & s2)  # 交集 拿2个集合相同的元素  shift + 7  &  （ 你和朋友都认识的人。）
print(s1 | s2)  # 并集  两个集合合并，相同只取一次，不同就都取（你们两人认识的所有人（不重复））
print(s1 - s2)  # 差集  s1 有但 s2 没有的值（我认识，但他不认识的人。）
print(s2 - s1)  # 差集  s2 有但 s1 没有的值（我认识，但他不认识的人。）
print(s1 ^ s2)  # 对称差集 （我们各自独有的好友）

fs = frozenset([1, 2, 3])
print(fs,type(fs))

set1 = {1,2,'小明'}
print(id(set1))

# 添加单个元素 add
set1.add('小红')
print(set1, id(set1))
# 对比id值可知，集合是可变类型

# 添加多个元素
# set1.update(['1', '2', '小明'])
# print(set1)

# 删除 (多运行几次就可以发现每次pop的值不一样，说明集合的无序) 随机删除并返回一个元素（因集合无序，无法指定）
# set1.pop()
# print(set1)

# remove  指定删除
# set1.remove('小明')
# set1.remove(1)
# 元素不存在会报错
# set1.remove(3)
# print(set1)

# discard  删除指定元素
# set1.discard(1)
# print(set1)
# 若元素不存在，无操作
# set1.discard(3)
# print(set1)


# in、 not in
s = {"apple", "banana"}
print("apple" not in s)   # 输出：True（存在）
print("orange" in s)  # 输出：False（不存在）

strings = input("请输入你最喜欢的动画片：")
print(type(strings), id(strings))

age = input("请输入你的年龄：")
print(age, id(age), type(age))
# '18' -> 18
age2 = int(age)
print(age2, type(age2))

# 两个数相加
a = input("请输入第一个数：")
b = input("请输入第二个数：")
print(a+b)