基础语法与数据结构

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

python -V
pip -V

D:\python\python382
D:\python\python312
D:\python\python368
D:\python\python3102

python -m pip install --upgrade pip
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# 或者
cat >~/.pip/pip.conf<<\EOF
[global]
index-url=https://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host=mirrors.aliyun.com
EOF
#+end_sr

*常用命令*
#+begin_src sh
pip install pkganme #安装包

(m353) [python@node web]$ pip freeze > requirement
(m353) [python@node web]$ mkdir ~/projects/pro1
(m353) [python@node web]$ cd ~/projects/pro1

[python@node pro1]$ pyenv local m364
(m364) [python@node pro1]$ mv ../web/requirement ./
(m364) [python@node pro1]$ pip install -r requirement

pip list
pip install ipython
ipython

pip install jupyter
jupyter notebook help
jupyter notebook --ip=0.0.0.0 --no-browser # 会输出 token

ss -tanl

d = 'd:\windows\nt'
print(d) # 会出现转义

# 解决方法1
d = 'd:\\windows\\nt' #比较麻烦

# 方法2
d = r'd:\windows\nt' # r 前缀将字符串不要转义了

str(1) + ',' + 'b' # 都转换成字符串拼接到一起
"{}-{}".format(1, 'a') # {}就是填的空，有2个，就使用2个值填充
"{0}-{0}".format('a') # {}就是填的空，用索引对应的值填充

# 在3.6后，可以使用插值
a = 100;
b = 'abc'
f'{a}-{b}' # 一定要使用f前缀，在大括号中使用变量名

a = 1.22333
print("a = {:.2f}".format(a))
print("a = %.2f" % (a))
#: a = 1.22
#: a = 1.22

#coding: utf-8
#format 对齐
#format处理 ={n:<2}= 冒号是分割符号， =<= 左对齐，后面的 n 表示变量对应的序号。
print('{0:<2} #'.format(2*3))
#居中对齐
print('{0:^3}'.format(2*3))

#: 6  #
#:  6 

\\ \t \r \n \' \"

上面每一个转义字符只代表一个字符，例如 \t 显示时占了4个字符位置，但是它是一个字符
前缀r，把里面的所有字符当普通字符对待，则转义字符就不转义了

a = 'abcd'\
'ef'

print(a) # abcdef

静态语言
const int b = 200;
int a=100; #定义变量的时候赋值了，要求变量必须是整数类型
a=200 #right
a ='abc'
# wrong#静态语言有了类型，有了约束。在编译的时候就可以做类型检查，提前发现问题

动态语言
a=100 #不需要指定类型，爱给什么给什么
a='abc' # a指问新的值，可以是新的类型
# 数据的类型没有任何的约束
# 在运行时，才能发现类型不对了，太晚了，

type(1 + 2) # int
type(1 + 2.1 + True) # int + float => float # 悄悄地，隐式的类型转换

print( 1 + 'a') # 报错，不能做隐式转换

print(str(1) + 'a') #  拼接 # 必须强制类型转换

# coding: utf-8

a = 10
b = 0xa # 十六进制
c = 0o12  # 八进制
d = 0b1010 # 二进制

print(a, b, c, d) #默认使用十进制展示
#10 10 10 10

# 10 --> 10 进制
123 = 1 * (10**2) + 2 * (10 ** 1) + 3 * (10**0)
123 = 1 * (10**2) + 2 * 10 + 3 * 1

# 2 --> 10 进制
ob1010 = 1 * (2 ** 3) + 0 * (2**2) + 1 *(2 ** 1) + 0 * (2**0)
ob1010 = 1 * (2**3) + 0 + 1 * (2**1) + 0
       = 1 * 8            +1 * 2
       8 + 0 + 2 + 0

# 8 --> 10 进制
0o12 = 1 * 8 + 2 * 1 = 10

# 16 --> 10 进制
0x11 = 1 * (16 ** 1) + 1 * (16 ** 0) = 1 * 16 + 1 * 1 = 17

1 bytes 8bits
00000000 无符号 0
00000011 # 3
       1 # 1
------------
     100 # 4

无符号数
00000000 # 0x00
   0   0
11111111 => 0xff => 15 * 16 + 15 * 1 = 255
   F   f

 11111111
+      1
---------
100000000 # 2 ** 8 = 256  上面 0xff = 256 - 1

2 0b       16 0x    10
1          1        1
11         3        3
111        7        7
1111       f        15
11111      1f       2**5 -1 =31; 16*1 + 15*1=31
111111     3f       63 2*6 - 1; 3f = 3f + 1 - 1 = 0x40 = 4 * 16 + 0 - 1 = 64 -1
01111111   7f       0x80 - 1 = 8 * 16 - 1 = 127
10000000   80       128
11000000   c0       0xc0 = 128 + 64 = 192
11111111   ff       255
100000000  100      256 

0~255 有多少种变化？ 0x00 ~ 0xFF ，256 种变化状态

# coding: utf-8
# 原码 人喜欢
# 2 16 8
print(bin(1), hex(1), oct(1))
#: 0b1 0x1 0o1

0b0000 0001 #正1
0b1000 0001 #原码负1
0b1111 1110 #反码负1

0b0000 0001 #正1
0b1000 0001 #原码负1
0b1111 1110 #反码负1
0b1111 1111 #补码负1，反码+1，0xff 255 如果代表的是有符号数，他其实是-1

0xfe 请问 1 字节的有符号数，请问它的十进制是多少？


1000 0010 # -2 原码
1111 1101 # -2 的反码
1111 0010 # -2 的补码， 0xfe

# coding: utf-8
print(bool(""))

print(
bool(0.1),bool(-0.0001), bool(0.00000)
)
#: False
#: True True False

3 + (-2) #  +符号双目 -符号单目
1 > 2, 1 <= 2, 1==2 # 双目

print(
float('1.2'), float(1), float('1e-2')
)
#: 1.2 1.0 0.01

# coding: utf-8
# ceil floor
print('ceil floor ------------')
import math # 导入 match 模块供你使用
print(math.ceil(2.5), math.ceil(-2.5)) # 大一点就向上取整
print(math.floor(2.5), math.floor(-2.5)) # 小一点就向下取整
#3 -2
#2 -3

# 整除 // 向下取整
print('// -----------')
print(1//2, 3//2, 5//2, 7//2)
print(1//-2, -3//2, 5//-2, -7//2)  # 负数部分，向下； // 向下取整。doc 文档 // 解释 x // y floored quotient of x and y 
#0 1 2 3
#-1 -2 -3 -4

# int 只截取整数部分
print('int ------------')
print(int(1.4), int(1.5), int(1.6))
print(int(-1.4), int(-1.5), int(-1.6))
#1 1 1
#-1 -1 -1

# round 正好 .5 的时候找离他最近的偶数，四舍六五入取偶
print('round ------------')
print(round(0.1), round(0.6), round(1.2), round(1.7), round(2.3), round(2.8))
print(round(0.50000001), round(1.5000001), round(2.50000001))
print(round(0.5), round(1.5), round(2.5), round(3.5))# 正好 .5 的时候找离他最近的偶数，四舍六五入取偶
print(round(-0.5), round(-1.5), round(-2.5), round(-3.5))
#0 1 1 2 2 3
#1 2 3
#0 2 2 4
#0 -2 -2 -4

# coding: utf-8
import math
print(math.pi) # pi 圆周率
print(math.e) # e 自然常数

print(math.pow(2, 3), pow(2, 3), 2 ** 3) #pow 求次方
print(math.sqrt(2), 2 ** 0.5) # 开方
#: 3.141592653589793
#: 2.718281828459045
#: 8.0 8 8
#: 1.4142135623730951 1.4142135623730951

# coding: utf-8
#max min 求最大最小值
#max(iterable, *[, default=obj, key=func]) -> value # 可迭代对象。 key 为高阶函数
#max(arg1, arg2, *args, *[, key=func]) -> value

print(max([1,2,3,4]), min([1,2,3])) # 可迭代对象
print(max(1,2,3,1,2)) # 当前是同种类型；不同类型就小涉及排序问题，要用到 key 高阶函数
print(min('a','b','c'))
#: 4 1
#: 3
#: a

if condition:
    代码块

if 1<2: # if True:
    print('1 less than 2') # 代码块

if condition1:
   代码块1
elif condition2:
   代码块2
elif condition3:
   代码块3
......
else:
   代码块

# coding: utf-8
a = 5
if a<0:
   print('negative')
elif a==0:  # 相当于 a >= 0
   print('zero')
else:  # 相当于 a > 0
   print('positive')

score = 80
if score<0:
   print('wrong')
else:
   if score==0:
      print('egg')
   elif score <= 100:
      print('right')
   else:
      print('too big')

while cond:
    block
while True: # 死循环
    pass

# coding: utf-8
a = 10
while a: # 条件满足则进入循环，找到边界
    print(a)
    a -= 1

for element in iteratable: # 可迭代对象中有元素可以迭代，进入循环体
    block
for i in range(0, 10):
    print(i)

print(range(3))
#: range(0, 3)

# coding: utf-8
print(range(0, 1))  # [0,1)  range(1)   0    1个数据    计数器
print(range(0, 10)) # [0,10) range(10)  0~9  10个数据   计数器

# coding: utf-8
# 打印奇数多种方法
for i in range(10):
    if i % 2 == 1:
       print(i)

for i in range(10):
    if i % 2:
       print(i)

for i in range(10):
    if i % 2 != 0:
         print(i)

for i in range(10):
    if i & 1: #位与 1 相与得 1，说明是奇数。
       print(i)

for i in range(1, 10, 2):
    print(i)

# 小结
# 上面的需要迭代 10 次，虽然位与挺有效率，但要做 cpu 计算就会消耗时间。
# 最后一个迭代了 5 次，而且只做加法，效率更高。

# coding: utf-8
# 打印偶数
for i in range(0, 10):
    if i % 2 == 0 :
        print(i)
for i in range(0, 10, 2):
    print(i)


# 倒着打印偶数
for i in range(8, -1 , -2):
    print(i)

# 倒着打印奇数
for i in range(9, 1 , -2):
    print(i)

# 2 ** 0 => 2 ** 10
for i in range(11):
    print(i, 2 ** i)

for i in range(0, 10):
    if i % 2 != 0 : continue
    print(i)

for i in range(10):
    if i % 2 != 0 :
        continue
    print(i)

for i in range(10):
    if i & 1:
       continue
    print(i)

# coding: utf-8
# 计算1000以内的被7整除的前15个正整数
count = 0
for i in range(7, 1000, 7):
    print(i)
    count += 1
    if count >= 15:
        print(count)
        break

for i in range(0): # 可迭代对象没有迭代
    pass
else:
    print('ok')

for i in range(0,10):
    break
else:
    print('ok')

for i in range(0,10):
    continue
else:
    print('ok')

真值表达式 if 条件表达式 else 假值表达式

#coding: utf-8
a = 5
if a > 5:
   print('> 5')
else:
   print('<= 5')
#: <= 5

# 三元表达式
a = 5
print('> 5') if a > 5 else  print('<= 5')
#: <= 5

s = '> 5' if a > 5 else '<= 5'
print(s)
#: <= 5

print('> 5' if a > 5 else '<= 5')
#: <= 5

# 判断用户的输入的值，如果为空，输出"empty"，否则输出该值
value = input('>>>')
if value:
    print(value)
else:
    print('empty')

value = input('>>>')
print(value if value else 'empty')

# coding: utf-8
#radius = int(input('radius = '))
radius = 5
pi = 3.14

C = 2 * pi * radius
S = pi * (radius ** 2)

print(C, S)
print("C = %.2f, S = %.2f" % (C, S))
#: 31.400000000000002 78.5
#: C = 31.40, S = 78.50

#first = int(input("1>>: "))
#second = int(input("2>>: "))
first = float("2.2")
second = float("3.2000001000000000010")

if first >= second:
   print(second, first)
else:
   print(first, second)

x = int(input("Plz input your first name : "))
m = x

while True:
    x = input('Plz input a number >>>')
#    if x == '':
#        break
    if x:
        x = int(x)
        if x > m:
            m = x
        print('Current Max Value = ', m)
    else:
        break

# coding: utf-8
#y = int(input('>>> '))
y = int('54321')
w = 10000  # 权位

x = y // w # 取模 5
y = y % w  # 取余 4321
print(x, y)
w = w // 10 # 1000

x = y // w # 取模 4
y = y % w  # 取余 321
print(x, y)
w = w // 10 # 100


x = y // w # 取模 3
y = y % w  # 取余 21
print(x, y)
w = w // 10 # 10

x = y // w # 取模 2
y = y % w  # 取余 1  , 最后余数
print(x, y)
w = w // 10 # 1


x = y // w # 取模 1
y = y % w  # 取余 0
print(x, y)
w = w // 10 # 0.1


#: 5 4321
#: 4 321
#: 3 21
#: 2 1
#: 1 0

# coding: utf-8
#y = int(input('>>> '))
y = int('54321')
w = 10000  # 权位

for i in range(5):
    x = y // w 
    y = y % w
    print(x, y)
    w = w // 10

#: 5 4321
#: 4 321
#: 3 21
#: 2 1
#: 1 0

# coding: utf-8
#y = int(input('>>> '))
y = int('54321')
w = 10000  # 权位

for i in range(4):
    x = y // w 
    y = y % w
    print(x, y)
    w = w // 10
else:
    print(y) # 少计算一次

# coding: utf-8
y = int('00321')
w = 10000
length = 5 #假设长度为 5
flag = False # 开关量，打标记，假定没找到第一个非 0

for i in range(5):
#while w:
    x = y // w
    if not flag:
        if x: # 找到第一个非 0 数字，从此才开始打印
            flag = True
        else:
            length -= 1
    if flag:
       print(x)
    #print(x, y)
    y = y % w
    w = w // 10

#print(y)
print("The length of the number is ", length)

# coding: utf-8
#num = int(input("Plz input num: "))

num = int('00300')
countnum = 0
str1 = ""
while True:
    #print(num%10)
    str1 = "{} {}".format ((num % 10),str1)
    num = num//10
    countnum +=1
    if num == 0:
        break
print("Your countnum:", countnum, "number:", str1)
#: Your countnum: 5 number: 5 4 3 2 1 

#coding: utf-8
n = 0
s = 0

while True:
    x = int(input('>>>'))
    if x == '':
        break

    s += x
    n +=1
    print('avg =', s /n)

n = 5
print('*'*n)
for i in range(n- 2):
    print('*'+' '*(n-2)+"*")
print('*'*n)

#coding: utf-8
char = '*'
n = 4

for i in range(n):
    if i == 0 or i == n-1: # 首尾是特例
        print(char * n)
    else:
        print(char + ' '*(n-2) + char)

#coding: utf-8
char = '*'
n = 4

for i in range(n):
    if i % (n-1) == 0: # 首尾是特例
        print(char * n)
    else:
        print(char + ' ' * (n -2 ) + char )

sum = 0
for i in range(1, 100):
    if i % 2 != 0:
       sum +=i
print(sum)

s = 0

for i in range(100):
    if i & 1 :
       s += i
print(s)

sum = 0
for i in range(1, 100, 2):
    sum += i
else:
    print(sum)

print(sum(range(1,100,2)))

score = '0'
score = int(score)

if score < 0:
   print('error input')
   exit()

if score >= 90:
   print('A')
elif score >= 80 
   print('B')
elif score >= 70
   print('C')
elif score >= 60
   print('D')
else:
   print('E')

# coding: utf-8

#n = int(input("请输入阶乘之和的数："))
n = 5
multiply = 1
sum = 0
for i in range(1, n+1):
    for j in range(1, i+1):
        multiply *= j
    sum +=multiply
    multiply = 1
#print(str(n) + "阶乘之和为：", sum)
print(str(n) , sum)

nums = 1
x = 0
for i in range(1, 6):
    nums *= i
    x += nums
print(x)

n=int(input("输入数字>>>: "))
for i in range(2, n):
    if n % i == 0:
        print(n , " is not prime")
        break
else:
    print(n," is prime")

for i in range(1, 10):
    for j in range(1, 10):
        print(i, j)

#coding: utf-8
for i in range(1, 10):
    line = '' # 重置，重头开始 
    for j in range(1,10): #凑一行
        line += str(i) + '*' + str(j) + '=' + str(i * j) + ' '
    print(line)

#: 1*1=1 1*2=2 1*3=3 1*4=4 1*5=5 1*6=6 1*7=7 1*8=8 1*9=9 
#: 2*1=2 2*2=4 2*3=6 2*4=8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18 
#: 3*1=3 3*2=6 3*3=9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27 
#: 4*1=4 4*2=8 4*3=12 4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36 
#: 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 5*6=30 5*7=35 5*8=40 5*9=45 
#: 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 6*7=42 6*8=48 6*9=54 
#: 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 7*8=56 7*9=63 
#: 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 8*9=72 
#: 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 

#coding: utf-8
for i in range(1, 10):
    line = '' # 重置，重头开始 
    for j in range(1,10): #凑一行
        line += str(j) + '*' + str(i) + '=' + str(i * j) + ' '
    print(line)

#coding: utf-8
for i in range(1, 10):
    line = '' # 重置，重头开始 
    for j in range(1,10): #凑一行
        if j <= i:
            #line += str(j) + '*' + str(i) + '=' + str(i * j) + ' '
            line += "{}*{}={} ".format(j,i,i*j) # format 格式化
    print(line)

#: 1*1=1 
#: 1*2=2 2*2=4 
#: 1*3=3 2*3=6 3*3=9 
#: 1*4=4 2*4=8 3*4=12 4*4=16 
#: 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
#: 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
#: 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
#: 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
#: 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

#coding: utf-8
for i in range(1, 10):
    line = ''
    for j in range(1, i+1): #凑一行， j [1,i)
        line += "{}*{}={} ".format(j,i,i*j)
    print(line)

#coding: utf-8
for i in range(1, 10):
    line = ''
    for j in range(1, i+1):
        line += "{}*{}={}\t".format(j,i,i*j)
    print(line)
#: 1*1=1        
#: 1*2=2        2*2=4   
#: 1*3=3        2*3=6   3*3=9   
#: 1*4=4        2*4=8   3*4=12  4*4=16  
#: 1*5=5        2*5=10  3*5=15  4*5=20  5*5=25  
#: 1*6=6        2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
#: 1*7=7        2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
#: 1*8=8        2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
#: 1*9=9        2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81  

#coding: utf-8
for i in range(1, 10):
    line = ''
    for j in range(1, i+1):
        line += "{}*{}={}{}".format(
            j,i,i*j,
            '  ' if i*j < 10 else ' '
        )
    print(line)

for i in range(1, 10):
    line = ''
    for j in range(1, i+1):
        line += '{}*{}={:<{}}'.format(
            j,i,i*j, 2 if j == i else 3
            )
    print(line)

for i in range(1, 10):
    line = ''
    for j in range(1, i+1):
        line += '{0}*{1}={2:<2} '.format(j,i,i*j)
    print(line)

#coding: utf-8
for i in range(1, 10):
    for j in range(1, i+1):
        line = '{}*{}={}'.format(
            j,i,i*j
            )
        print(line, end=' ') # 往后打印
    print() # 默认行为 end='\n'

#coding: utf-8
for i in range(1, 10):
    for j in range(1, i+1):
        print('{}*{}={}'.format(j,i,i*j), end=' ') # 往后打印
    print()

#coding: utf-8
for i in range(1, 10):
    for j in range(1, i+1):
        print('{}*{}={}'.format(j,i,i*j),
              end=' ' if j != i else '\n') # 往后打印

#coding: utf-8
for i in range(1, 10):
    for j in range(1, i+1):
        print('{}*{}={:<{}}'.format(j,i,i*j, 2 if j==1 else 3),
              end='' if j != i else '\n') # 往后打印

#coding: utf-8
username = 'tom'
password = 'tom' #不可逆算法，单向加密


success = False

for i in range(3):
    u = input('Plz input your username =')
    p = input('Plz input your password =')
    if username == u and password == p:
        success = True
        pass
    else:
        print('Invalid username or password')

if success:
    print('Login successfully')
    pass # 显示登录页
else:
    print('Failed')
    pass # 退出程序

for i in range(-3, 4):
    if i < 0:
        prespace = -i
    else:
        prespace = i
    print(' '*prespace + '*'*(7-prespace*2))

for i in range(-3, 4):
    prespace = abs(i)
    print(' '*prespace + '*'*(7-prespace*2))

n = 7
leadingchar = ' '
char = '*'

for i in range(-3, 4):
    print("{:^7}".format((7-2 * abs(i)) * char))

n = 7
e = n // 2 # 3
leadingchar = '='
char = '*'

for i in range(-e, n-e):
    print("{:=^{}}".format((n - 2 * abs(i)) * char, n))

#: ====*====
#: ===***===
#: ==*****==
#: =*******=
#: *********
#: =*******=
#: ==*****==
#: ===***===
#: ====*====

n = 7
e = n // 2
leadinchar = '#'
char = '*'

for i in range(-e, e+1):
    spaces = e - abs(i)
    chars = 2*abs(i)+1 
    print('{}'.format(leadinchar * spaces + char * chars))
#: *******
#: #*****
#: ##***
#: ###*
#: ##***
#: #*****
#: *******

n = 7
e = n // 2
leadinchar = '#'
char = '*'

for i in range(-e, e+1):
    chars = 2*abs(i)+1 
    print('{:^{}}'.format(char * chars,n))

n = 7
e = n // 2

for i in range(-e, e+1):
    if i == 0 :
        print( '*' * n)
    print(' ' * (-i) + '*' * (e+1+i)) if i < 0 else  print(' ' * e  + '*' * (e+1-i))
#:    *
#:   **
#:  ***
#: *******
#:    ****
#:    ***
#:    **
#:    *

i = 1
j = 1
while i < 100:
    print(i)
    i, j = j, j+i

i = 1
j = 1
count = 0

while True:
    i, j = j, j+i
    count +=1
    if count == 100:
        break
print(i)

print(1)
print(2)
print(3)
for i in range(3, 10000, 2):
    m = i**0.5
    for j in range(3, i, 2):
        if i % j == 0:
            break
        if j> m:
            print(i)
            break

count = 0
for x in range(2, 100):
    for i in range (2, x):
        if x % i == 0:
           #print('not a prime number', i)
           break
    else:
        #print(x)
        count += 1
print(count)

#coding: utf-8
count = 0
for x in range(2, 100):
    for i in range (2, int(x**0.5)+1): # [2, "中点"]，range 只能包含整数，int向下取整，一定会漏掉一个所以 +1
        if x % i == 0:
           #print('not a prime number', i)
           break
    else:
        #print(x)
        count += 1
print(count)

#coding: utf-8
import datetime

start = datetime.datetime.now()

count = 0
for x in range(2, 100000):
    for i in range (2, int(x**0.5)+1): 
        if x % i == 0:
           #print('not a prime number', i)
           break
    else:
        #print(x)
        count += 1

delta = (datetime.datetime.now() - start).total_seconds() # 它不是精确的 CPU，它是墙上的时间
print(count, delta)

#: 9592 0.351471

#coding: utf-8
import datetime

start = datetime.datetime.now()

count = 1 # 2 偶数，同时是质数

#算奇数
for x in range(3, 100000, 2): # 只测试奇数，减少一半计算量
    for i in range (3, int(x**0.5)+1, 2): 
        if x % i == 0:
           #print('not a prime number', i)
           break
    else:
        #print(x)
        count += 1

delta = (datetime.datetime.now() - start).total_seconds() # 它不是精确的 CPU，它是墙上的时间
print(count, delta)

#: 9592 0.180551

#coding: utf-8
import datetime

start = datetime.datetime.now()

count = 1 # 2 偶数，同时是质数

#算奇数
for x in range(3, 100000, 2): # 只测试奇数，减少一半计算量
    if x > 10 and x % 5 == 0:
       continue
    for i in range (3, int(x**0.5)+1, 2): 
        if x % i == 0:
           #print('not a prime number', i)
           break
    else:
        #print(x)
        count += 1

delta = (datetime.datetime.now() - start).total_seconds() # 它不是精确的 CPU，它是墙上的时间
print(count, delta)

#: 9592 0.180551

ls1 = [] # 空列表
ls2 = list() #空列表
ls3 = [2, 'ab', [3, 'abc'], (5, 30, 50)] # 列表是一个容器，元素可以是其它类型
ls4 = list(range(5)) # 非常常用的构造方式，将一个可迭代对象转换为一个新的列表
ls5 = list([1, 'a', 100]) # 从[1, 'a', 100] 中遍历所有元素，组建一个新的列表

ls3 = [2, 'ab', [3, 'abc'], (5, 30, 50)]
print(
ls3[0], ls3[2], ls3[-4]
)
#: 2 [3, 'abc'] 2

# -*- coding: utf-8 -*-
ls1 = [1, 2, 3,2, 3, 4, 5, 6, 7, 8, 9]

print(ls1.index(2)) # Return first index of value
print(ls1.index(2,2), ls1[3]) #找到 2 出现的索引中从第 2 个索引地址开始找，返回索引
print(ls1.index(2,2,7)) #找到 2 出现的索引中从第 2 个索引到 第 7 个索引地址开始找，返回索引
#: 1
#: 3 3
#: 3

print(ls1.count(2)) #2 值出现的次数
print(ls1[2]) # 无规模 n 无关，不会随着规模 n 的增加而影响效率
print(len(ls1)) # len效率如何？ O(1)。因为 [1,2,3,4] 列表包装的 C 语言的数组，记录了一个数据当前列表长度
#: 2
#: 3
#: 11

ls1 = [1,2,3,4]
ls1[2] = 200

# -*- coding: utf-8 -*-
#append
ls1 = []
ls1.append(1) # append 内部尾部追加，没有返回值。没有返回值往往表示它自己被改变了，就地修改
print(ls1)
# append 效率如何？
#虽然说列表是容器，但是有容量， python 中列表可以扩大，自动扩大，会先给初始大小，不够了扩容，扩增4倍，达到一定限度2倍扩
#扩容耗时，如果内存连续空间不够，牵扯到了垃圾回收，效率低了。

#insert
ls2 = [10, 20, 30, 50, 20, 40, 60]
ls2.insert(-1, 70) # 不是 append，在当前索引前面插入
print(ls2)
ls2.insert(10000, 'abc') # None 没有返回值，超界 右边界，相当于 append
print(ls2)
ls2.insert(0, 80) # 插入到队首
print(ls2)
ls2.insert(-1000, 100) # 左边界超界，相当于插入到 队首
print(ls2)
#: [10, 20, 30, 50, 20, 40, 70, 60]
#: [10, 20, 30, 50, 20, 40, 70, 60, 'abc']
#: [80, 10, 20, 30, 50, 20, 40, 70, 60, 'abc']
#: [100, 80, 10, 20, 30, 50, 20, 40, 70, 60, 'abc']
# insert 方法效率如何？
# 超界的情况不要考虑
#insert index 说明定位高效
#插入点之后所有数据向后挪动，效率极低。规模越大，挪动数据越多
#最差情况，插入到队首；最好情况，队尾追加

#coding: utf-8
# extend
ls2 = [10, 20, 30, 50, 20, 40, 60]
ls2.extend(range(110,150,10)) # 就地尾部后扩展
ls2.extend([1,2])
print(ls2)
#: [10, 20, 30, 50, 20, 40, 60, 110, 120, 130, 140, 1, 2]

#效率高吗 还行 ls2.extend([1,2]) ==> for x in [1,2]: ls2.append(x)

# +
l1 = [1,2]
l2 = [11, 22]
x = l1 + l2 # 2 个列表组合连接在一起，返回一个全新的列表
#l1 + 3 报错，强类型
print(x)
#: [1, 2, 11, 22]
#效率，在规模巨大时，要不要创建一个全新的对象也是你要考虑的

# *
y = [9] * 3 # 将给的列表的元素重复 3 次，生成全新的列表
print(y)
#: [9, 9, 9]

ls1 = [1] * 5
ls2 = [None] * 6
ls3 = [1,2] * 3
ls4 = [[1]] * 3
print(ls4)
#: [[1], [1], [1]]

x = [1] * 3
x[0] = 100
print(x) # 结果是什么

#coding: utf-8
y = [[1]] * 3
print(y) # 结果是什么
y[0] = 100
print(y) # 结果是什么
y[1][0] = 200
print(y) # 结果是什么
#: [[1], [1], [1]]
#: [100, [1], [1]]
#: [100, [200], [200]]

# -*- coding: utf-8 -*-
# remove
ls1 = [10, 20, 30, 50, 20, 40, 60]
ls1.remove(10) #效率高吗？ 遍历， O(n)，移除掉中间的元素，其后所有元素向前挪动，效率极差
print(ls1) # 队首移除，效率最低了

# pop
x =ls1.pop(0) # index = 0 移除，效率高吗？ 效率一样低下，就是用索引找得快，移除元素后，其余元素挪动，效率低
# 以后，遇到了pop 这样的名字，都可以叫做弹出来，弹出返回值
print(x)
ls1.pop() # pop 尾部移除最后一个元素，尾部怎么找， lenght起点。效率可以

# clear
ls1.clear() # 效率高，标记不用了，lenght 标记为 0。 内存清除操作谨慎，想好再作。
print(ls1)

# -*- coding: utf-8 -*-
# reverse
ls1 = [10, 20, 30, 50, 20, 40, 60]
ls1.reverse() # 最没用的方法之一。列表如果想倒过来读取，使用负索引倒着读就行
print(ls1)
#: [60, 40, 20, 50, 30, 20, 10]

for i in range(-1, -len(ls1)-1, -1):
    print(ls1[i])

# -*- coding: utf-8 -*-
# sort 重要
ls1 = [10, 20, 30, 50, 20, 40, 60]
ls1.sort() # None, 就地修改，默认升序排序
print(ls1)
ls1.sort(reverse=True) # 降序
print(ls1)

#: [10, 20, 20, 30, 40, 50, 60]
#: [60, 50, 40, 30, 20, 20, 10]

ls2 = [1,2,3,'a',11]
ls2.sort(key=str) # ? if str(元素0) < str(元素1) str 转换后的值用来进行比较，决定先后次序，但不影响输出
print(ls2)
#: [1, 11, 2, 3, 'a']

ls2 = [1,2,3,'12',11] 
ls2.sort(key=int)
print(ls2)
#: [1, 2, 3, 11, '12']

'a' in ['a', 'b', 'c']
[3,4] in [1, 2, 3, [3,4]]

for x in [1,2,3,4]:
    pass

#coding: utf-8
ls1 = [1,2,3,4,5,6]
print(-1 in ls1) #效率不高，遍历。找不到不抛异常，性能低下，规模大的业务少用
print(1 in ls1)
if not -1 in ls1: print('-1 not in ls1')
#print(1s1.index(-1)) #效率不高，遍历。找不到抛异常

#: False
#: True
#: -1 not in ls1

#coding: utf-8
# 复制
x = [1,2,3]
y = x
print(x,y)
print(x == y) # y 就是 x ，内容相同，可以不是同一个对象。指向相同的内存地址
print( x is y ) # is 比较在内存中是不是同一个地址，本质问是不量同一个对象
print(id(x), id(y)) #id() 显示内存地址
#: [1, 2, 3] [1, 2, 3]
#: True
#: True
#: 2648564816128 2648564816128

# 复制本质？
x = [1,2,3]
y = x.copy() # 复制方法，复制一个全新的对象，内容相同
print(x,id(x))
print(x == y)
print(x is y, id(x),id(y))
#: [1, 2, 3] 2321011307904
#: True
#: False 2321011307904 2321013245440

#coding: utf-8
a = list(range(4))
b = list(range(4))
print(a == b)
c = a #指向同一个内存地址
c[2] = 10
print(a)
print(a == b) # 还相等吗？
print(a == c) # 相等吗？
#: True
#: [0, 1, 10, 3]
#: False
#: True

#coding: utf-8
a = list(range(4))
b = a.copy()
print(a == b)
a[2] = 10
print(a == b)

#
a = [1, [2, 3, 4], 5]
b = a.copy()
print(a == b)
a[2] = 10
print(a == b,a,b) #: False [1, [2, 3, 4], 10] [1, [2, 3, 4], 5]
a[2] = b[2]
print(a == b)
a[1][1] = 100
print(a == b,a,b) # 还相等吗？ : True [1, [2, 100, 4], 5] [1, [2, 100, 4], 5]

#coding: utf-8

#列表
x = [] # 新建的空列表 []，地址交给了 x，引用计数为1

import sys
print(sys.getrefcount(x)) # 函数调用自动加 1， 用完减 1
#: 2

y = x
print(sys.getrefcount(x))
print(sys.getrefcount([])) #实际 [] 引用计数 0 ，调用完后，适当的时候，GC 清理它
#: 3
#: 1

a = 1 # 字面常量，数值或字符串等，他们是常量，常量处理不同，一旦创建不允许改动，因此没有必要在内存保存很多份
print(sys.getrefcount(a))
b = a
print(sys.getrefcount(a))
#: 4294967295
#: 4294967296

#coding: utf-8
#排序算法，所有程序员的基础，大厂 一定考算法
nums = [9,1,8,5]
length = len(nums)

for i in range(length - 1):
    for j in range(length - 1 - i):
        if nums[j] > nums[j+1]: # 相邻比较，交换
            temp = nums[j]
            nums[j] = nums[j+1]
            nums[j+1] = temp
    print(nums) # 每一趟走完的当前情况
print('----------------')
print(nums) # 最终结果

#: [1, 8, 5, 9]
#: [1, 5, 8, 9]
#: [1, 5, 8, 9]
#: ----------------
#: [1, 5, 8, 9]

#coding: utf-8
#排序算法，所有程序员的基础，大厂 一定考算法
nums = [1,9,8,5,6,7,4,3,2]
length = len(nums)
count = 0
swap_count = 0

print(nums)
print('~~~~~~~~~~~~~~')

for i in range(length - 1):
    for j in range(length - 1 - i):
        count += 1
        if nums[j] > nums[j+1]: # 相邻比较，交换
            temp = nums[j]
            nums[j] = nums[j+1]
            nums[j+1] = temp
            swap_count += 1
    print(nums) # 每一趟走完的当前情况
print('----------------')
print(nums) # 最终结果
print(count, swap_count) # 比较次数、交换次数

#coding: utf-8
#排序算法，所有程序员的基础，大厂 一定考算法
#nums = list(range(1, 10)) # 升序， count = 9(9-1)/2=36; swap = 0
nums = list(range(9,0, -1)) # 最差情况
#nums = [9,8,1,2,3,4,5,6,7]
length = len(nums)
count = 0
swap_count = 0

print(nums)
print('~~~~~~~~~~~~~~')

for i in range(length - 1):
    flag = False # 假设这一趟没有交换过
    for j in range(length - 1 - i):
        count += 1
        if nums[j] > nums[j+1]: # 相邻比较，交换
            temp = nums[j]
            nums[j] = nums[j+1]
            nums[j+1] = temp
            swap_count += 1
            flag = True
    print(nums) # 每一趟走完的当前情况
    if not flag:
       break
print('----------------')
print(nums) # 最终结果
print(count, swap_count) # 比较次数、交换次数

#coding: utf-8
s1 = 'string'
s2 = "string2"
s3 = '''this's a "String" ''' # 有单引号、双引号，用三绰号包裹
s4 = 'hello \n xxx.com' # 转义字符 \n 用 print 才能看到 
s5 = r"hello \n xxx.com" # r 前缀阻止 \n 转义
s6 = 'c:\windows\nt'
s7 = R"c:\windows\nt" # 方法1 加 r 前缀不转义
s8 = 'c:\windows\\nt' # 方法2 \ 用 \\ 转义表示

name = 'tom'; age = 20 # python代码写在一行，使用分号隔开，不推荐
s9 = f'{name}, {age}' # 3.6支持 f 前缀，使用变量插值
sql = """select * from user where name='tom' """ # 长语句用三引号比较方便
print(sql)
#: select * from user where name='tom' 

sql = "select * from user where name='tom'"
print(sql[4]) # 字符串'c'
sql[4] = 'o' # 不可以

s = 'hello'

for i in s:
    print(type(i), i)
# python 中没有其他语言的 char 类型
#: <class 'str'> h
#: <class 'str'> e
#: <class 'str'> l
#: <class 'str'> l
#: <class 'str'> o

x = 'ab'
x = x + 'cd'

print(','.join(x))
print('\t'.join(x))
print('\n'.join(x))
print('-'.join(range(5))) # 可以吗， 不可以 

#coding: utf-8
s = 'a' + 'b'
s2 = 'cde'

print(s, s2)
print(','.join(s2))
print(list(s2), tuple(s2))
print(''.join(['a','b','cd'])) # join 可迭代对象必须是字符串
print('\n'.join(map(str,range(5)))) # \n 代表一个字符
#: ab cde
#: c,d,e
#: ['c', 'd', 'e'] ('c', 'd', 'e')
#: abcd
#: 0
#: 1
#: 2
#: 3
#: 4

s = 'xxx.edu'
print(s.find('edu'))
print(s.find('edu', 3))
print(s.find('edu', 4))
print(s.find('edu', 6, 9))
print(s.find('edu', 7, 20))
print(s.find('edu', 200))

s = 'xxx.edu'
print(s.rfind('edu'))
print(s.rfind('edu', 3))
print(s.rfind('edu', 4))
print(s.rfind('edu', 6, 9))
print(s.rfind('edu', 7, 20))
print(s.rfind('edu', 200))

#coding: utf-8

s = 'xxx.edu'
print(s.index('edu'))
print(s.index('edu', 3))
print(s.index('edu', 4))
#print(s.index('edu', 6, 9)) # 抛异常
#print(s.index('edu', 7, 20)) # 抛异常
#print(s.index('edu', 200)) # 抛异常

#coding: utf-8

x = '\n'.join('1234')
#print(x.index(1)) #抛异常，找的必须是字符串
y = '1234'
print(y.index('123'))
#: 0

#coding: utf-8

s = 'xxx.edu'

print(s.count('edu'))
print(s.count('edu', 4))
#: 1
#: 1

#coding: utf-8
s = ','.join('abcd')
print(s.split(','))
print(s.split())
print(s.split(',', 2)) # 指定切割次数
#: ['a', 'b', 'c', 'd']
#: ['a,b,c,d']
#: ['a', 'b', 'c,d']

s1 = '\na b \tc\nd\n' # 注意下面3个切割的区别
print(s1.split()) # 空白、换行符、tab，统称为空白字符 space。切割行为是：尽可能长的空白字符
print(s1.split(' ')) 
print(s1.split('\n'))
print(s1.split('b'))
#: ['\na', 'b', '\tc\nd\n']
#: ['', 'a b \tc', 'd', '']
#: ['\na ', ' \tc\nd\n']

# rsplit 从右向左切割
print(s1.rsplit())
print(s1.rsplit('\n'))
#: ['a', 'b', 'c', 'd']
#['', 'a b \tc', 'd', '']

print(s1.splitlines()) # 按行切割。
print(s1.splitlines(True)) # 是否保留切掉的换行符
#['', 'a b \tc', 'd']
#['\n', 'a b \tc\n', 'd\n']

s = ','.join('abcd')
print(s.partition(','))
print(s.partition('.')) # 没有切入点时，后两个元素是空串
print(s.rpartition(','))
print(s.rpartition('.'))
#: ('a', ',', 'b,c,d')
#: ('a,b,c,d', '', '')
#: ('a,b,c', ',', 'd')
#: ('', '', 'a,b,c,d')

#coding: utf-8
s = ','.join('abcd')
print(s.replace(',', ' '))
print(s.replace(',', ' ', 2))

s1 = 'www.xxx.edu'
print(s1.replace('w', 'a'))
print(s1.replace('ww', 'a'))
print(s1.replace('ww', 'w')) # 返回什么？
print(s1.replace('www', 'a'))
#: aaa.xxx.edu
#: aw.xxx.edu
#: ww.xxx.edu
#: a.xxx.edu

#coding: utf-8

s = '\t\r\na b c,d\ne\n\t'
print(s.strip()) # 拿掉两端的空白字符
print('-' * 30)
print(s.strip('\t\n'))
print('-' * 30)
print(s.strip('\t\ne\r')) # 两端字符在这个字符集就拿掉

s = "www.xxx.edu"
print(s.startswith('ww'))
print(s.startswith('e', 7)) #从索引 7 位置开始找
print(s.startswith('e', 10))
print(s.startswith('edu', 11))
print(s.endswith('edu'))

#coding: utf-8
f = 'abcdef'

print(f.upper())
print(f.lower())
print('Abc'.istitle()) # 对于英文，title 首字母要大写
print(" \t\r\n\f".isspace())
print('012'.isnumeric()) # 是数字吗，不认小数点
print('012'.isdigit()) # 是数字吗，不认小数点
print('abc_123'.isidentifier()) # 是标识符吗。不以数字开始，字母、数字、下划线吗
#: ABCDEF
#: abcdef
#: True
#: True
#: True
#: True
#: True

dnf -y install man-pages
man ascii

# coding: utf-8
a = '\x00'
print(a,type(a),len(a)) #C 语言中，字符串尾部都有结束符，就是 null 字符，长度多个 1
c = '\t' # '\x09' 1 个字符

d = '\r\n' # 回车换行 '\x0d0a' \r \x0d \n \x0a
e = '\x20' # 空格

#\x31 49 字符1 , \x41 65 A, \x61 97 a

print('aAa' > 'aA') # true，使用相同的编码逐字节比较

# coding: utf-8

print('a\x09b\x0d\x0ac \x31\x41\x61') # 表示什么？
print('A' > 'a') # 谁大？

#a\tb\r\nc 1Aa
#False

sequence[start:stop] # 前包后不包
sequence[start:stop:step]

# coding: utf-8

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[0:], x[:]) #全部
print(x[1:])  # 掐头
print(x[:-1], x[0:-1]) # 去尾
print(x[1:-1]) # 掐头去尾
print(x[3:])
print(x[3:-1]) #
print(x[9:])
print(x[:9])
print(x[9:-1])
print(x[:100]) # 可以超界
print(x[-100:], x[-1000::1]) # 默认步长为1
print(x[4:-2])
print(x[-4:-2])
print('0123456789'[-4:8])
print(b'0123456789'[-4:8])
print(bytearray(b'0123456789')[-10:5])

# 步长
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[::], x[:], x[::1]) # 等价，默认步长为 1
print(x[::-1]) # 真的逆序了，但 x 不变，返回全新的
print(x[::2])
print(x[2:8:3])
print(x[:9:3])
print(x[1::3])
print(x[-10:8:2])

# 起止和方向
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[-10:])
print(x[-5:6])
print(x[-5:-6])
print(x[6:5])
print(x[5:5])
print(x[1:9:-2])
print(x[::-2])
print(x[8::-2])
print(x[8:2:-2])
print(x[8:-10:2])
print(x[8:-10:-2])
print(x[-5:4:-1])
print(x[-5:5:-1])

# 使用id看地址，要注意地址回收复用问题
print(id([1,2,3]))
print(id([4,5,6,7]))
# 上下两句可能内存地址一样，但是上面那个[1,2,3]没有意义，因为它用完之后，引用计数为0了，没人能再次访问到，释放了内存
# 如果2个存在在内存中的对象，地址一样一定是同一个对象

# coding: utf-8

x = [0, 1, 2]
y = x[:]
print(x, y)
print(id(x), id(y))
x[0] = 100
print(x ==y, x, y)
#[0, 1, 2] [0, 1, 2]
#1548029799232 1548029797120
#False [100, 1, 2] [0, 1, 2]

#切片是浅拷贝
x = [[1]] * 5
y = x
print(x == y, x is y)
z = y[:] 
print(z)
x[0][0] = 300
print(z)
print(id(x), id(y), id(z))
#True True
#[[1], [1], [1], [1], [1]]
#[[300], [300], [300], [300], [300]]
#2049030455872 2049030455872 2049030038272

x = [[1]]
y = x[:]
print(x, y)
print(x == y)
print(id(x), id(y), x is y)
x[0][0] = 100
print(x, y)
print(x == y)
print(x is y)
x[0] = 200
print(x == y) # ?
print(x, y)
#[[1]] [[1]]
#True
#2049030455936 2049030456000 False
#[[100]] [[100]]
#True
#False
#False
#[200] [[100]]

# coding: utf-8
a = list(range(5))

t = list()
t[:] = a
print(t ==a, t is a,t)
#: True False [0, 1, 2, 3, 4]

t[1:2] = (50,)
print(t)
t[1:] = range(10,20) # 覆盖加扩展
print(t)
#: [0, 50, 2, 3, 4]
#: [0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

t[1:8] = [20] #覆盖
print(t)
#: [0, 20, 17, 18, 19]