【python自动化筑基篇】

# -*- coding: utf-8 -*-
"""
@Author  : 南方朱雀
@Time    : 2023/4/3 21:00
@Email : 359493550@qq.com
@File    : 筑基篇.py
"""
# 十进制
a = 10
print(a, type(a))

# 二进制 前导符0b
b = 0b100
print(b, type(b))

# 八进制 前导符0o
c = 0o10
print(c, type(c))

# 十六进制 前导符0x
d = 0x10
print(d, type(d))
********************************************************************
#2.浮点数类型的表现形式
a = 1.2 # z正常的 a.b
print(a, type(a))
b=0.0 #浮点数的小数部分是可以为0的
print(b, type(b))
c=76.#当一个浮点数小数部分为0的时候.后面可以省略不写
print(c, type(c))
d=-3.1415 #负的浮点数
print(d, type(d))
e=9.5e-2 # 科学计数法 9.5e-2 9.5 / 10^2
print(e, type(e))
f = 3.14E3 # 3.14 * 10^3
print(f, type(f))
g=.76 #当一个浮点数的整数部分为0的时候也可以省略不写
print(g, type(g))
# 3.思考:浮点数可以表示所有的整数数值，python为何要同时提供两种数据类型?
# 相同的操作整数比浮点数要快5-20倍
# 因为计算机的底层表示整数和浮点数的方式不一样
# 4.数学运算符
# + - * / // % ** ()
print(1+1)
print(2-1)
print(2*2)
print(14/3)#/运算之后的结果一定是浮点数
print(9/3)
print(14//3) # 地板除 两个整数使用// 的结果也是整数 舍去小数部分 向下取整
print(14.0 // 3) # 如果有浮点数 使用 // 结果是将小数部分设置为0
print(10 % 3)
print(2**3)
print((1+3)/2)

# 5.组合赋值运算符
age =18
# 自加一
age += 1 # age =age+ 1
算术运算符要写在前面 两个运算符之间不能有空格
print(age)
age -=1 #age=age-1
print(age)
age *= 2 # age = age * 2
print(age)
age /= 2 #age= age / 2
print(age)
# 6.浮点数的不精确性
#python提供无限精度的整数运算
print(0.1 + 0.2)
import sys
print(sys.float_info.dig)
# 一般情况下计算机只能提供15个数字的小数位的准确性，浮点数超过15位之后产生误差
# 7.思考3.1415926535897924*1.23456789 的计算怎么准确
print(3.1415926535897924*1.23456789)
print(31415926535897924*123456789)
# 拓展
#高精度浮点运算类型
import decimal
a=decimal.Decimal('3.1415926535897924)
b =decimal.Decimal('1.23456789')
print(a*b)
print(type(a))
# 8.浮点数和整数的相互转化
#int,float 是python的内置函数，通过它们可以实现整数和浮点数的相互转换
a=0.9999999
b=0
# float -> int
int(float) 直接舍弃小数部分
c =int(a)
print(c)
# int -> float float(int) 在整数的后面加上小数0
d = float(b)
print(d)
import math
print(math.ceil(0.9))
# math.floor()
# 9.复数
a = 12.3 + 4j
print(a, type(a))
print(a.real, a.imag)
                  
                  
                  
python中的基本数据类型，4大类
1.数值类型
    整数类形
    浮点数类形
    复数类型!
2.序列类型
     表达有序的元素的集合
        - 字符串
        - 列表
        - 元组           
3.散列类型
4.其他类型
                  
                  
# 1.索引的定义
索引是序列中元素所在的位置
字符串是字符的序列，单个字符在字符串中的位置用索引来表示
索引，下标
索引使用整数来表示
为什么索引从日开始，索引是所在位置距离序列开头的偏移量
# 2.索引的作用
可以通过索引获取对应位置的元素
s[index] 代表从字符串s中，获取索引为index的字符
s = 'Hello, world!'
print(s[2])


![在这里插入图片描述](https://img-blog.csdnimg.cn/b57c051bb432438bbaecb8875de8d66a.png#pic_center)

            
# 2.语法
序列切片的语法
s[start:end:step]
start:切片开始的索引
end:切片结束的索引
step:步长,默认等于1，可以不写
3.[start:end]
s1='0123456789'
                  
 《5.字符串常用方法》      
# 1.内建函数dir
#接受任何数据作为参数，返回这个数据对象的所有的方法名的列表
print(dir(''))
                
# 2.内建函数help
s = 'hello'
print(help(s.capitalize))                
 s = 'hello'
print(help(s.capitalize))
# 官方文档：https://docs.python.org/zh-cn/3/library/stdtypes.html?utmsource=testingpai.com#string-methods
# 几乎是所有的字符串方法都是返回一个新的字符串
new_s = s.capitalize()
print(new_s)
s1 = 'abc'
s2 = '#####'
print(s1.isalnum())
print(s2.isalnum())

s3 = '12345'
print(s3.isdigit())
print(s1.isdigit())

s4 = 'ABC'
print(s4.islower())
print(s4.isupper())

s5 = '028-1314521-010'
print(s5.replace('-', ''))
print(s5.replace('-', '', 1))

print(s5.split('-', 1))
print(s5.split('-'))  
                  
《字符串和数值的相互转换》    
# 1.1整数转字符串
a = 25
str_a = str(a)
print(a)
print(str_a, type(str_a))

# 1.2浮点型转字符串
salary = 500.5
str_salary = str(salary)
print(str_salary, type(str_salary))

# 2.数值字符串转数值
# 2.1 整数字符串转整数
int_str = '20'
age = int(int_str)
print(age, type(age))

# 2.2 数值字符串转浮点数
print(float('1.5'))
print(float(20))                                                     
# 4.[start:end:step]
     
                  
# 字符串和数值的相互转换
'''
# 1.1整数转字符串
a = 25
str_a = str(a)
print(a)
print(str_a, type(str_a))

# 1.2浮点型转字符串
salary = 500.5
str_salary = str(salary)
print(str_salary, type(str_salary))

# 2.数值字符串转数值
# 2.1 整数字符串转整数
int_str = '20'
age = int(int_str)
print(age, type(age))

# 2.2 数值字符串转浮点数
print(float('1.5'))
print(float(20))
'''

# 字符串的格式化

# 1.% 字符串格式化
# 老的，继承自c语言
# 语法:
# %[(name)][fLags][width][.precision]typecode

time = '11:15'
percent = 75
# 应为%是槽位(需要被替换的地方)的标志，所以模板字符串中不能单独使用%
# 所以如果需要单独输出%就需要%%
format_str = '%s计算机的内存利用率为%s%%'
# 基本使用
# 按顺序，把变量或者值替换对应的槽位
res = format_str % (time, percent)
print(res)
# typecode 是必须，替换的时候用变量或者是值得类型
# s 等价于先把值str一下，然后再替换到模板字符串中

# 月份 1-12，输出的宽度，字符的个数
# 1-》01 2-》02 。。 9-》09 10 11 12
month =1
# 输出宽度为2左边以0填充的月份表示形式
print('%06d' % month)

'''
2.format方法 格式化字符串
str.format
功能比%更强大，官方推荐
<模板字符串>.format(<逗号分隔的参数>)
在模板字符串中使用{}代替了以前的%typecode 作为槽位
'''
time = '11:15'
percent = 75
format_str = '{}计算机的内存利用率为{}%'
res = format_str.format(time, percent)
print(res)

# {索引}，索引指定那个参数
print('{1}计算机的内存利用率为{0}%'.format(time, percent))
# {参数名}， 参数名对应参数
# 一旦槽位中使用了参数名，format方法里的参数也要使用参数名
print('{a}计算机的内存利用率为{b}%'.format(a=time, b=percent))

# 复杂用法
'''
{[参数序号][:格式控制标记]}
其中格式控制标记格式如下
[fill][align][sign][#][@][width][,][.precision][type]
'''
# 输出两位数的月份，例如01，02
res = '{:$^5}'.format(9)  # >右对齐 < 左对齐 ^居中对齐 =
print(res)

# 保留两位小数
time = '11:15'
percent = 75.599
# format 可以不写typecode
# 小数默认使用科学计数法
format_str = '{}计算机的内存利用率为{:.2f}%'
print(format_str.format(time, percent))

print('{:,}'.format(1000000000))

num = 10
print('num的十进制是：{0:d},八进制是：{0:#o}，十六进制是{0:#x}'.format(num))  # #是前导符非必填
'''
3.6的新功能
1. 定义:
格式字符串字面值，也称为f-string f字符串f表达式
是标注了'f'/'F'前缀的字符串字面值。
这种字符串包含了替换槽位，也就是{}标注的表达式
基本语法:
Literal_char{expression[:format spec]}
-literal char: 普通的字符
-expression:表达式，变量，函数
-format spec:格式字符串，规则和format里的面的控制字符一模一样
'''

item = '11:15'
percent = 75
f_str = f'{item}计算机的内存利用率为{percent:.2f}%'
print(f_str)

# 带格式的f字符串
# 输出两位数的月份，例如01，02
month = 8
res = f'{month:0>2}'
print(res)

num = 10
res = f"十进制{num:d},八进制{num:#o}"
print(res)

# 包含运算和函数的f字符串
print(f'{num+1}')
s = '*'
print(f'{s*10}')
print(f'{abs(num)}')

s = 'absd'
print(f'{s[::-1]}')               
                                
                
《列表的索引和切片》              
                  
# 列表的嵌套
# lst = [1, 2, 3, ['a', 'b', 'c', ['赵', '钱', '孙', '李']]]
# print(lst[0])
# print(lst[3][2])
# print(lst[3][3][3])

'''
1. 增加
- 一个一个的加
- 加再最前面
- 加在最后面
    -.append(element)
        -接收元素，追加到列表的最后面
    -指定一个位置插入
        -.insert(index, element)
        -在列表指定的位置插入一个元素
        -index 就是索引
        -element就是元素
- 一次加多个
    -.extend(iterable)
    -iterable 是可迭代对象(比如列表，比如字符串)
2.删除
    -删除一个元素
        -.pop(index=-1)
            -删除指定索引的元素，并返回该元素，如果不指定索引默认删除最后一个元素
    -.remove(value)
            -从列表中删除第一个指定的值value，如果不存在则报错
    -删除多个元素
     -.clear()
        - 清空列表    
'''
"""
# 追加
# ls = [1, 2, 3, 4]
# res = ls.append(5)
# print(ls)

# 插入
# ls = [1, 2, 3, 4]
# res = ls.insert(2, 0)
# print(ls)

# 一次性多加几个
# 扩展，把一个列表里的值扩展到另外一个列表中去
ls1 = [1, 2, 3]
ls2 = [4, 5, 6]
ls1.extend(ls2)
print(ls1)
ls2.extend('abcd')
print(ls2)
"""
# 删除
# ls = [1, 2, 3]
# res = ls.pop()
# print(res)
# print(ls)

# 指定值删除
# 删除第一个 1
# ls = [1, 2, 3, 1]
# res = ls.remove(1)
# print(res)
# print(ls)

# 删除多个元素 清空
# ls = [1, 2, 3, 1]
# res = ls.clear()
# print(res)
# print(ls)

# 修改
# ls = [1, 2, 3]
# ls[2] = 'w'
# print(ls)
'''
列表的其他方法
dir
help
.copy() 返回列表的一个浅拷贝(可变与不可变)
.index(value，start=0，stop=很大很大的一个数)
    - 返回列表中value的第一个索引，start，stop表示的是范围，默认情况下是整个列表
    - 如果value不存在会报错
.reverse
    - 翻转列表的顺序
.sort(key=None, reverse=False)
    - 排序
'''
# print(dir([]))    # 返回所有列表可用的方法

# ls = [1, 3, 5, 7, 6, 9, 2, 8]
# ls.sort()
# print(ls)
#
# ls.sort(reverse=True)
# print(ls)
 
ls = [1, 3, 5, 7, 6, 9, 2, 1]
res = ls.index(2)
print(res)
res = ls.index(1, 1)
print(res)

ls.reverse()
print(ls)