py二

### 数据类型
x = 10
#类型判断
print(type(x))
#转为整数
print(int(x))
#转为浮点数
print(float(x))
#转为二进制
print(bin(x))
#转为八进制
print(oct(x))
#转为十六进制
print(hex(x))
#转为字符串
st = str(x)
print(st, type(st))

a = '0b1010'
b = int(a, base = 2)#参数a, base进制类型
print(b, type(b))

<class 'int'>

10

10.0

0b1010

0o12

0xa

10 <class 'str'>

10 <class 'int'>

# 浮点数
## 整数要比浮点数的运算精度要高 pow(x,n) x是底数，n是幂。 x^n
print(pow(1010,25))#可以精确到前面30几位
print(pow(1010.0,25))#只能精确到前面20几位

## 存在不确定尾数
#受限于计算机浮点数使用宽度，计算的二进制数并不是0.1和0.2，二是计算机内部接近0.1和0.2的二进制数。求的的数反映到十进制就会产生一个不确定的尾数。
a = 0.1 + 0.2 #a = 0.30000000000000004
if a == 0.3:
    print("yes")
else:
    print("no")

print(a)
#未解决这个问题，使用round()函数保留几位小数
print(round(a,2)) #保留两位小数 0.30
if round(a,2) == 0.3:
    print("yes")

1282431995017233613592752029298389976325673030025010000000000000000000000000

1.2824319950172337e+75

no

0.30000000000000004

0.3

yes

#复数
a = 3 + 4j
print("real获取实部", a.real)
print("imag获取虚部", a.imag)

real获取实部 3.0

imag获取虚部 4.0

print(4/2)
print(4/3)
print(4//3)
print(2**2)

# 二元数组
divmod(10, 3) #(商后取整，商后取余)
pow(2, 3, 2) #2的3次方是8，再除以2，取余为0

# 按位运算符
print(bin(0b1010 & 0b0110))
print(bin(0b1010 | 0b0110))
#print(bin(0b1010 ~ 0b0110))
print(bin(0b1010 ^ 0b0110))

2.0

1.3333333333333333

1

4

0b10

0b1110

0b1100

# 类型判断
# type(字符串) -> 返回类型
# isinstance(字符串，类型) -> 返回 True 或 False
print(isinstance("广州", str))
print(isinstance("广州", int))
print("广州".encode()) #编码为字节串类型

print("\x43") # => C
print(r"\x43") #字符串前加r或者R标识原字符串，常用在文件路劲、URL和正则表达式

True

False

b'\xe5\xb9\xbf\xe5\xb7\x9e'

C

\x43

# 字符串索引、字符串切片 [N:M:step], N是切片终止索引号（开区间不包含），M切片长度，step切片步长
s = "世界那么大，我想去看看"
print(s[0])
print(s[0:4])
print(s[0:4:3])

print(s[-1])
print(s[-4:-2])

# 字符串运算
a = "one"
b = "one TWO"
c = a * 3 #字符串复制3次
print(c)
print(a in b)
print(len(a))

# 字符串
print(ord("钱")) #返回单字符对应的UniUnicode编码
print(chr(38065)) #返回Unicode对应的单字符

# 字符串处理方法
print(b.upper())
print(b.lower())
print(b.split(sep=None)) #返回默认以空格分割的sub子字符串
print(b.split(sep="n")) #返回以n分割的sub子字符串
print(c.count("o"))
print("replace:", b.replace("TWO", "two"))

print(b.center(15, "*")) #center(width, fillchar), 目标字符居中，width字符最终的长度，fillchar字符填充
print(b.center(10, "*"))

print("##berave####".strip("e#"))
ls = ["objc", "swift", "flutter"]
print("**".join(ls)) #每个元数后面加**

# format 使用
print("{1}那么大，{0}想去看看".format("我", "世界"))
s = "python"
print("{:*^10}是最牛逼的".format(s))
print("{:*<10}是最牛逼的".format(s))
print("{:*>10}是最牛逼的".format(s))

i = 126832173980
print("{:*^5,}是最牛逼的".format(i)) #引导好，填充，对齐，长度，千位分隔符

a = 3.1415
print("{:*^10.3}是最牛逼的".format(a)) #.精度保留的是有效数字 3.14
print("{:*^10.3f}是最牛逼的".format(a)) #.f精度保留的是几位小数 3.142

print("{0:b},{0:c},{0:d},{0:o},{0:x}".format(10)) # 1010,\n,10,12,a

世

世界那么

世么

看

想去

oneoneone

True

3

38065

钱

ONE TWO

one two

['one', 'TWO']

['o', 'e TWO']

3

replace: one two

****one TWO****

*one TWO**

berav

objc**swift**flutter

世界那么大，我想去看看

**python**是最牛逼的

python****是最牛逼的

****python是最牛逼的

126,832,173,980是最牛逼的

***3.14***是最牛逼的

**3.142***是最牛逼的

1010,

,10,12,a

# try...except...
s = input("请输入数字1")
while 1:
    try:
        print("请输入数字try")
        s = int(s)
        print("结果",s)
        break
    except ValueError:
        print("请输入数字2")
        s = input("请输入数字3")

请输入数字1请输入数字try

结果 44

请输入数字4

# try...except...else... (else只有在try代码块没引发异常情况下执行)

a = input("请输入数字")
while 1:
    try:
        a = int(a)
    except ValueError:
        print("error")
        a = input("请输入数字")
    else:
        print(a)
        break

请输入数字请输入数字56

# try...except...finally... 无论try代码块是否发生异常，finally代码块总会执行
#自定义函数
def caculate(a, b):
    try:
        print(a/b)
    except ZeroDivisionError:
        print("除数不能为0")
    finally:
        print("done")

z = eval(input("请输入一个数"))
caculate(5,z)

请输入一个数0.5555555555555556

done

def caculate(a, b):
    try:
        print(a/b)
    except ZeroDivisionError:
        print("除数不能为0")
    except TypeError:
        print("类型错误，请输入数字")
    else:
        print("未出现异常")
    finally:
        print("done")

# z = eval(input("请输入一个数"))
# caculate(5,z)
caculate(5,"c")

类型错误，请输入数字

done

# 创建列表
ls = ["123", 123, [1,2,3,'stud']]
print(ls)
print(ls[2][3][-1]) # d
type(ls)

x = [1,2,3,4,5,6,1,2,3,1,2,3,4]
print(x.count(4)) # 4出现几次
print(x.index(2)) # 首次出现2的索引值，2必须存在与数组，否则报错

# 数组后面添加元数
x.append(6) #操作，无返回值，不能打印
print(x)

# 插入
x.insert(1,'9')
print(x)

# 数组后面添加多个元数
x.extend(['10','12'])
print(x)

# 删除元数，找到第一个元数删除
x.remove(1)
print(x)

# popp(x) 找到表中第x位删除，默认 -1 位
x.pop(-2)
print(x)

# del x[d]移除表中的第d位元数
del x[2]
print(x)

# 元数反转
x.reverse()
print(x)

# 清除所有元数
x.clear()
print(x)


x = [1,2,3,4,5,6,1,2,3,1,2,3,4]

# sort 排序，reverse=False 升序
x.sort(reverse=True)
print(x)

cc = x.copy()
print(cc)

['123', 123, [1, 2, 3, 'stud']]

d

2

1

[1, 2, 3, 4, 5, 6, 1, 2, 3, 1, 2, 3, 4, 6]

[1, '9', 2, 3, 4, 5, 6, 1, 2, 3, 1, 2, 3, 4, 6]

[1, '9', 2, 3, 4, 5, 6, 1, 2, 3, 1, 2, 3, 4, 6, '10', '12']

['9', 2, 3, 4, 5, 6, 1, 2, 3, 1, 2, 3, 4, 6, '10', '12']

['9', 2, 3, 4, 5, 6, 1, 2, 3, 1, 2, 3, 4, 6, '12']

['9', 2, 4, 5, 6, 1, 2, 3, 1, 2, 3, 4, 6, '12']

['12', 6, 4, 3, 2, 1, 3, 2, 1, 6, 5, 4, 2, '9']

[]

[6, 5, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1]

[6, 5, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1]

# 列表运算符
#增加元数，返回新列表
x = [1, 2]
print("+前列表地址：", id(x))
x = x + [4]
print(x) #[1, 2, 4]
print("+后列表地址：", id(x))

# +=原地操作
x += [5]
print(x)
print("+=后列表地址：{}\n".format(id(x)))

s = [1, 2]
#列表重复，返回新列表
print("*前列表地址：", id(s))
s = s*2
print(s)
print("*后列表地址：", id(s))

# *=原地操作
s *= 2
print(s)
print("*=后列表地址：{}\n".format(id(s)))

+前列表地址： 140293932989088

[1, 2, 4]

+后列表地址： 140293934414656

[1, 2, 4, 5]

+=后列表地址：140293934414656

*前列表地址： 140293932989088

[1, 2, 1, 2]

*后列表地址： 140293934414576

[1, 2, 1, 2, 1, 2, 1, 2]

*=后列表地址：140293934414576

# 元组
x = ['a', '牛', 'b', '1',[2023, 'study']]
y = tuple(x)
print(y)
print(y[1])
print(y[4][1][1:3])
z = ('1', '3', 456)
print(z)

('a', '牛', 'b', '1', [2023, 'study'])

牛

t

('1', '3', 456)