python基础整理（上）

# 1.the first day 单行注释
print("输出双引号里面的东西")
# 2.多行注释 回车换行可以继续注释 两种方法看情况来用
"""
多行注释
主要是用来换行写
单行 多行都可以
"""
'''
多行 单行 都可以

'''
# 3.交互模式和开发模式
"""
交互模式例子有两个
第一个是win+r 
输入cmd
输入一个代码 回车执行
第二个是idle
打开文本模式（开发模式）
需要保存文件才能运行

开发模式
代码可以保存，写完所有代码再执行文件
"""
# 4.变量 作用：储存数值
a = 1
b = 3
result = a + b
print(result)

a = "坚持"
print(a)

a = "1"
a = "2"
print(a)

"""
变量的总结：
1.result = 4(储存数值)
#print的作用：说明print通过输出a+b是可以计算数值的
2.输出结果为 坚持(储存数值)
3.输出结果为 2 (变量可以进行覆盖，以最新赋值的数据为准)
"""

# 5.数据类型
"""
-number(数字类型)
  int(整型)#整数-1 0 1 2 3 4 5 6 7
  ·格式：
       变量名 = 整数(注意注意注意：“=”赋值，“==”等于)
       a = 1 创建整型int
  float(浮点类型)小数 0.1 0.3 0.4 2.2
  ·格式：
        变量名 = 小数(小数点)
        a = 1.0 创建浮点类型
-bool(布尔类型)(只有两个值 True 和 false)
  ·格式：
        变量名 = True
        变量名 = False
  重点 重点 重点：boolbool的值True和False首字母一定是大写，后面一定是全部小写
        a = true
        print(type(a))# 报错
        
        a = TRUE
        print(type(a))# 报错
-str
  string(字符串)
a="hello word"  
切片 print(a[1:2])
长度 print(len(a))
替换 replace(old,new,number)number就是代替的个数，默认-1就是全部代替，一般都从第一个开始替代  
  拓展：
	字符串是不能修改的，和元组一样，使用replace这些方法都不能修改原数值,replace暂存代替的数据，运行代码后直接清除
strip() 格式：strip(字符串)：删除字符串前后指定连续数值,匹配时不按顺序
a = "! !!!123456!!! !!!"
print(a.strip("!"))

print(a.strip("! "))

a = "! !!!123! 456!!! !!!"
print(a.strip("! "))
# !!!123456!!! 
#123456
#123! 456

rstrip()
rstrip():删除字符串后面指定连续数值
a = "! !!!123456!!! !!"
print(a.rstrip("!")) # ! !!!123456!!!

split()
split(字符串, 数值)：输入的字符串为分割点进行分割，是以列表形式输出，数值默认是-1，也就全部分割,如果是其他数值，就是分割多少次
a = "12345678951234"
print(a.split("5"))
print(a.split("5",1))

# 如果分割次数大于分割点，默认为-1
print(a.split("5",5))

split()
a = "12345678951234"
print(a.split("5"))
print(a.split("5",1))

# 如果分割次数大于分割点，默认为-1
print(a.split("5",5))

格式：
	upper():把字符串的字母都改为大写
	lower():把字符串的字母都改为小写
	title():把字符串的单词首字母都改为大写


find(字符串):查询字符串是否含有某个数值并且输出某个数值最先查询到的下标值，如果查不到就会输出-1
a = "hello word"
print(a.find("l"))
print(a.find("a")) # 输出-1

endswith()
endswith():查询结尾是否为输入的字符串，如果是有存在就返回True，如果不是返回False
运用：判断文件后缀  ####你把整个都输进去都是True
a = "hello word"
print(a.endswith("rd"))
print(a.endswith("wd"))

isdigit()
isdigit():是否只由数字组成，如果是就返回True，如果不是就返回False
a = "01234567"
print(a.isdigit())

a = "01234567A"
print(a.isdigit())

%d	替换整型		
%f	替换浮点类型
%s	替换字符串类型

# %d
a = 26.0
print("今年%d岁" % a)

# %f
a = 26
print("今年%f岁" % a)

# %s
a = "26岁"
print("今年%s" % a) 

format()
print("又{0}又{1}".format("高","帅"))
print("又{1}又{0}".format("高","帅"))
拓展：可以设置变量固定代替位置
print("百度地址：{url}，我是{name}".format(name="hh", url="www.baidu.com"))

f-Sring
格式：f''
a = "高"
b = "帅"
print(f'同学们又{a}又{b}')
-tuple 元组
    元组和列表类似，是可以储存多个数值，类似我们的保险箱
    格式：元组名 = (数值1, 数值2) #有逗号才是元组
    元组的特性 数组是不可以修改内部值
    注意一下：标识符不能使用tuple()，也是一个强制性转化函数
    1.切片
    a = (1,2,3,4)
    print(a[::2])
    2.拼接
    a = (1,2,3)
    b = (4,)
    c = a + b
    print(c) #(1, 2, 3, 4)

    3.咨询
    a = (1,2,3,4)
    print(a[2]) #3
    
    4.删除
    序列的删除就是物理的删除。就是从内存地址进行删除
    a = (1,2,3,4)
    del a
    print(a)
    # Traceback (most recent call last):
  File "E:/python作业代码/作业/基础作业/text.py", line 3, in <module> print(a) NameError: name 'a' is not defined

    5.元组与列表的相互转换
    a = [1,2,3,4]
    print(a)
    print(type(a))
    
    a = tuple(a)
    print(a)
    print(type(a))
    
    #--转化为列表
    a = (1,2,3,4)
    print(a)
    print(type(a))
    
    a = list(a)
    print(a)
    print(type(a))
-dict 字典
    格式:
    dict(字典)= {key:value}
    key 的值是可以用数字，字符串和元组组成，但是不能用list列表和dict字典作为key
    
    增删改查
    格式:dict.update({key:value})
    有相同的key值就会修改里面的value值
    修改可以用这两个：
    1.dict[key]=value
    
    2.格式：dict.setdefault(key，default=None) None = 空值
    定义：输入的key如果是没有进行添加value，如果没有进行定义value默认认为空值None，如果是存在键值对，不会进行报错，也不会添加
    用default相同key值不相同的值修改是不会把原来的key值改变的
    
    a = {"1": 1, "2": 2, "3": 3}
    a.setdefault("3", 0)
    a.setdefault("4")
    a.setdefault("5", 1)
    print(a)
    #{'1': 1, '2': 2, '3': 3, '4': None, '5': 1}
    
    pop()
    格式：dict.pop(key)
    格式：dict。popitem()#删除最后一个键值对
    del dict #全删
    del dict[key]#单删
    dict.clear()#清空键值对
    
    查询
    格式：dict[key]
    a={"q":12}
    print(a["q"]) #q
    
    items()
    定义：获得字典的key值和value值。而且是以元组形式放在列表形式展示
    格式：dict.items()
    
     a = {"a":1,"ww":2}
     print(dict.items())
     print(type(a.items())) #对象类型
     #dict_items([('a', 1), ('ww', 2)])
     #<class 'dict_items'>
     
     values()
     key()
     定义：
     values:获得字典所有value值，返回的一个数值是list形式展示
     keys：获得字典所有key值，返回的一个数值是list形式展示
     dict.values()
     dict.keys()
     
     fromkeys()
     定义：用于创建或者批量创建相同数值的字典方法，而且是以key为键值，value为数值，如果没有输入value值，默认为None空值。
     
     格式：fromkeys(key,default=None)
     
    a = {}
    b = ("1", "2", "3")
    a  = a.fromkeys(b)
    print(a)
    
    a = a.fromkeys(b,100)
    print(a)
#{'1': None, '2': None, '3': None}
#{'1': 100, '2': 100, '3': 100}

-list 列表
    #特征：[],里面是用，分割 [1,2,3,4]
    命名的规范：单字母和小驼峰法命名，但是大家一定不能用list这个名字去命名
list是一个内置函数，使用转类型的，把其他类型转换为列表
补充：，是分割的意思，没有下标值
    li = []
    1.count(数值)统计列表某个数值的个数
    print(a.count(number))
    2.index(数值)查询列表某个数值的下标值
    print(a.index(number))#查到第一个就会报，如果没有就会报错
    3.in 和 not in
    a = [1,2,3,4,5]
    print(1 in a)#在print()里面写in和not in 数值in 或 not in 在某个变量
    print(100 not in a)#返回bool值
    4.增加
    append
    在尾部追加
    格式 
    a.append(数值) 或者 b = 某个数值 ，a.append(b) 
    print(a)
    5.插入
    insert
    格式：insert(下标值，数值) 插入的下标值的数值往后移，下标值变成想要插入的数值
    a.insert(1,2)  如果下标值长度大于列表本身就会默认插入最后一个
    print(a)
    6.加入
    extend
    extend():可以按照添加的序列逐个添加到目标列表末尾里面
    a = [1,2,3,4]
    a.extend([5,6,7])
    print(a)
    
    b = [1,2]
    b.extend("hello word")
    print(b)
    
    [1, 2, 3, 4, 5, 6, 7]
    [1, 2, 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'd']
    
    7.删除
    pop() #pop():是标识删除的列表的下标值，如果你没有标明具体的下标值，那默认是最后一个
    a.pop()
    8.移除
    remove()#remove():是移除填写特定值，如果是相同值会匹配移除第一个值，如果列表里面没有数值，就会报错
    a.remove(number)
    print(a)
    8.删除
    del #del:这个是一个函数，作用是删除一个或者是连续多个值（切片）
    a = [1,2,2,3,3,4]
    del a[2:4]
    print(a) #[1, 2, 3, 4]
    9.清除
    clear():清楚列表所有值
    a = [1,2,3,4,5]
    a.clear()
    print(a)
    10。更改
    格式：列表名[下标值] = 数值
    a = [1,2,4,4]
    a[2] = 3
    print(a)
    11.嵌套
    a = [[1,2,3],[4,5,6]]
    print(a[1])
    print(a[1][2])
    # [4, 5, 6]  记得这个，小白天天忘
    # 6
    
-set 集合
    格式：set{1，2，3，4}
    print(a)
    print(type(a))
    
    add()
    a={1,12,3,4}
    a.add(5)
    print(a)
    
    remove()
    discard()
    格式：set.remove(数值)
    set.discard(数值) #remove如果数值不存在会报错
                      discard如果数值不存在也不会不会报错
    并集 交集 差集
    &交
    |并
    -差
    set1={1,2,3}
    set2={3,4,5}
    print(set1&set2)
"""
# 6.运算规则
'''
#运算规则
1.  数值类型运算规则
    a = 1+1 
    print(a)
    结果为2
    说明python是可以先计算再赋值
2.
    b = 1 + 1.0
    print (type(b)) # 运行结果为float类型
    自动转换：运行等级低的向运算等级高的进行转换
    float > int
    
3.  关于bool类型运算规则
    a = True
    b = False
    print(a+b)
    print(type(a+b))
    结果为
    1
    <class 'int'>
    
    a = True + 0
    b = False + 0
    print(a)
    print(b)
    结果为
    1
    0
    说明True = 1 False = 0
'''
# 7.查看数据类型
a = "坚持"
print(a)
print(type(a))

a = 26
print(a)
print(type(a))
"""
输出结果为
坚持
<class 'str'>
26
<class 'int'>
"""

# 8.数据类型的转换：
# str类型与int类型进行转换
a = "123"
a = int(a) + 1
print(a)
# str类型与float类型进行转换
b = "12.3"
b = float(b) + 1
print(b)
# bool类型与int类型进行转换
a = True
b = int(a) + 2
print(b)
print(type(b))  # 结果为3
"""
转换为int->int()
转换为float->float()
转换为str->str()
"""

# 9.标识符与关键字
"""
标识符：一个给名字命名的总称(变量名 函数名 方法名)
标识符规则：
1.首字母必须是大小写字母，或者是下划线[_]
2.标识符只能是由大小字母、数字、下划线组成，不能有【！】【~】
3.标识符不能与关键字和内置函数相同【print】【input】【while】【if】...
使用方法：
（见面思意就是我们命名是有意义的，并不是杂乱无章，就是我们看到名字就要知道这个意思）
myname:我的名字
myage：我的年龄
myheight：我的身高
shenggao:我的身高
驼峰命名法：
	顾名思义就是类似我们骆驼的驼峰一样的命名方式（小驼峰法）：
	myName.myAge,myHeight.shengGao

定义：第一个单词是首字母小写，然后第二个单词是首字母大写

大驼峰法：
定义：第一个单词是首字母大写，然后第二个单词是首字母大写
MyName,MyAge,MyHeight,ShengGao
"""
# 10.关键字
import keyword

print(keyword.kwlist)  # 用来避免标识符出错()

# 也可以使用help()函数去查看是否为关键字
print(help('print'))

# 11.字符串
a = "坚持"
print(a)
# 12.引号嵌套使用
a = "子曰：'君君，臣臣，父父，子子'"
# 13.转义（使引号可以随便出现）
a = "子曰：\"君君，臣臣，父父，子子\""  # 子曰："君君，臣臣，父父，子子"
a = "子曰：\'君君，臣臣，父父，子子\'"  # 子曰：'君君，臣臣，父父，子子'
# 其他转义
a = "hh\nnn"  # 换行转义\n
# hh
# nn
a = "as\tdf"  # as	df 制表转义\t
a = "as\\ndf"  # as\ndf  取消转义 为了让\n在句子中出现
a = r"as\\ndf"  # as\\ndf  取消转义 可以把”里面的转义都取消“

# 14.数值获取 最好就是负数就全是负数 正数就全是正数 不要一正一负
# 切片
a = "qwertyui"
b = a[1:2]
c = a[1:3]
d = a[-2:]
print(b)  # w
print(c)  # we
print(d)  # ui
# 这个切片只能从左往右切不可以从右往左
# 步长
a = "12345678"
# 获取字符串a的“246”
b = a[1:7:2]
print(b)
# 获取字符串a的奇数
c = a[::2]
print(c)
# 获取字符串a的偶数
d = a[1::2]
print(d)
# 获取字符串a的“27”
e = a[1:7:5]
print(e)
# 【起点下标 : 终点下标：步长值】它会直接选取起点下标作为第一个数，当步长超过了终点坐标就会停止截取
# 15.逆向输出
a = 'hello word'
b = a[::-1]
print(b)  # drow olleh  把步长变成负数就可以逆向输出 起点变成-1:终点变成0:
# 步长也还是有步长的作用
a = 'hello word'
b = a[::-2]
print(b)  # do le  原理：hello word d开始截一下 ro为两个步长 o为第二个步长所以截一下 然后w和空格又为两个步长 空格为第二个所以截，以此类推

# 16.测长度
a = '123456'
print(len(a))  # 6
# 主要再字符串赋值中，空格也是算一个字符数
b = 'Hello word'
print(b)  # 10