2、流程控制及基本数据类型

a, b, c = 1, 2, 3 # 等号右侧实际是个元组
print(a) # 1
print(a, c) # 1 3

a, b = 1, 2  # 变量定义
a, b = b, a  # 交换赋值
print("a:%s,b:%s" % (a, b))  # a:2,b:1

values = (1, 2, 3)
x, y, z = values
print("z:%s,y:%s,z:%s" % (x, y, z))  # z:1,y:2,z:3

users = {"name": "cce", "age": 18}
key, val = users.popitem()
print(key)  # age
print(val)  # 18
print(users)  # {'name': 'cce'}

lst = [1, 2, 3, 4, 5]
first, *other, end = lst
print(first, end)  # (1, 5)
print(other)  # [2, 3, 4]

x = y = (1, 2, 3)
# 上面的代表实际上等价于
y = (1, 2, 3)
x = y
# 但是需要注意的是，上面的语句和如下的语句，不能完全等价，因为下面的语句是完全独立赋值，上面则的将y的引用赋值给了x；
y = (1, 2, 3)
x = (1, 2, 3)

x = 0
x = x + 1
print(x)  # 1
# 上面是我们正常逻辑思想下，对一个数值进行固定值增加的时候做的方式，那么转换为增强赋值如下；
x = 0
x += 1
print(x)  # 1

x = "cce"
x += 'cfj'
x *= 2
print(x)  # 'ccecfjccecfj'

print(True)  # True
print(False)  # False
print(True == 1)  # True
print(False == 0)  # True
print(True + False + 42)  # 43
# 使用bool函数来验证布尔值是真值还是假值
print(bool(1))  # True
print(bool(0))  # False

# 单分支
if condition:
    body
---
# 双分支
if condition:
    body
else:
    body
---
# 多分支语句
if condition:
    body
elif condition:
    body
...
else:
    body

>>> input('Please enter your name: ') or '<unknown>'
Please enter your name: cce
'cce'
>>> input('Please enter your name: ') or '<unknown>'
Please enter your name: 
'<unknown>'

>>> assert 1==2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

>>> age = -1
>>> assert 0 < age < 100, 'The age must be realistic'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: The age must be realistic

continue：continue语句，表示结束此轮循环，进入下一次循环，继续往下执行；
break：break语句，表示跳出循环，也就是结束循环的意思，不往下继续执行；
pass：pass是空语句，pass不做任何事情，主要是为了保持程序结构的完整性，所以一般用来做占位符；

numbers=[1,2]
for num in numbers:
    print(num)
else:
    print("end")
# 1
# 2
# end

lst1=["cce","cfj"]
lst2=[18,10]
for index in range(len(lst1)):
         print("name: %s,age: %s" %(lst1[index],lst2[index]))
# name: cce,age: 18
# name: cfj,age: 10

lst1 = ["cce", "cfj"]
lst2 = [18, 10]
lst3 = ['1', '1']
print(list(zip(lst1, lst2, lst3)))  # [('cce', 18, '1'), ('cfj', 10, '1')]

# “缝合”后，可在循环中将元组解包；
lst1 = ["cce", "cfj"]
lst2 = [18, 10]
for name, age in list(zip(lst1, lst2)):
    print(name, age)
# cce 18
# cfj 10

lst = ['ce', 'sd', 'cce', 'cfg', 'asd']
for string in lst:
    if 'cce' in string:
        index = lst.index(string)  # 在字符串列表中查找字符串 lst[index] = '[censored]'
        lst[index] = '[censored]'
print(lst) # ['ce', 'sd', '[censored]', 'cfg', 'asd']

lst = ['ce', 'sd', 'cce', 'cfg', 'asd']
for index, string in enumerate(lst):  # enumerate会返回两个值，第一个是迭代值当前的索引号，第二个是索引值
    if 'cce' in string:
        lst[index] = '[censored]'
print(lst) # ['ce', 'sd', '[censored]', 'cfg', 'asd']

# sorted # 排序
data = [
    {"name": "cce", "age": 22, "height": 170},
    {"name": "cfj", "age": 18, "height": 80},
    {"name": "dwc", "age": 10, "height": 120}
]
# 根据年龄排序
print(sorted(data, key=lambda item: item.get("age")))  # [{'height': 120, 'age': 10, 'name': 'dwc'}, {'height': 80, 'age': 18, 'name': 'cfj'}, {'height': 170, 'age': 22, 'name': 'cce'}]
# 根据身高排序
print(sorted(data, key=lambda item: item.get("height"))) # [{'height': 80, 'age': 18, 'name': 'cfj'}, {'height': 120, 'age': 10, 'name': 'dwc'}, {'height': 170, 'age': 22, 'name': 'cce'}]

# reversed  反转，不排序
lst=[1,2,3,4]
print(list(reversed(lst))) # [4, 3, 2, 1]

count=0
while count <= 10:
    print('count is',count)
    count+=1

while True:
    print('死循环')
或者
while 1 == 1:
    print('死循环')

broke_out = False
for x in seq:
    do_something(x) 
    if condition(x):
        broke_out = True
        break 
    do_something_else(x)
if not broke_out:
    print("I didn't break out!")

# 打印出了“no break”，表示该循环是正常退出，并没有使用break语句跳出循环
lst=[1,2,3]
for num in lst:
    if num == 4:
        break
    print(num)
else:
    print("no break")
1
2
3
no break

print("cce" if 1==2 else "cfj") # cfj
# 真值放在前面，假值放在后面

+ : 加法运算；
- : 减法运算；
* : 乘法运算；
/ : 除法运算；
** : 求次方；
% : 求余数；
// : 求商；

# 求次方
print(pow(2,10)) # 1024

# 求绝对值
print(abs(-10)) # 10

# 四舍五入
print(round(1.3)) # 1

str1="str1"
str2='''str2'''
str3=str("str3")
print(str1,str2,str3) # str1 str2 str3

>>> website="https://www.baidu.com"
>>> website[-3:]
'com'
>>> website[-3:]="cn"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

string.capitalize():把字符串的第一个字符大写；
string.casefold():把字符串的所有字符都变成小写；
string.center(width):返回一个原字符串居中,并使用空格填充至长度 width 的新字符串；
string.count(str, beg=0, end=len(string)):返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数；
string.decode(encoding='UTF-8', errors='strict'):以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace'；
string.encode(encoding='UTF-8', errors='strict'):以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'；
string.endswith(obj, beg=0, end=len(string)):检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False；
string.expandtabs(tabsize=8):把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8；
string.find(str, beg=0, end=len(string)):检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1；
string.format():格式化字符串；
string.index(str, beg=0, end=len(string)):跟find()方法一样，只不过如果str不在 string中会报一个异常；
string.isalnum():如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False；
string.isalpha():如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False；
string.isdecimal():如果 string 只包含十进制数字则返回 True 否则返回 False；
string.isidentifer():判断是否是标识符，如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格；
string.isdigit():如果 string 只包含数字则返回 True 否则返回 False.;
string.islower():如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False;
string.isspace():是否是空白字符；
string.isnumeric():如果 string 中只包含数字字符，则返回 True，否则返回 False;
string.isspace():如果 string 中只包含空格，则返回 True，否则返回 False.;
string.istitle():如果 string 是标题化的(见 title())则返回 True，否则返回 False;
string.isupper():如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False;
string.join(seq):以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串，需要注意是的join是将可迭代对象一个一个元素迭代出来，和第二个元素拼接;
string.ljust(width,str):返回一个原字符串左对齐,并使用指定字符填充width长度的新字符串，默认空格填充;
string.lower():转换 string 中所有大写字符为小写.;
string.lstrip():截掉 string 左边的空格;
string.maketrans(intab, outtab]):maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。;
max(str):返回字符串 str 中最大的字母。;
min(str):返回字符串 str 中最小的字母。;
string.partition(str):有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串string分成一个3元素的元组(string_pre_str,str,string_post_str),如果string中不包含str 则 string_pre_str == string.;
string.replace(str1, str2,  num=string.count(str1)):把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.;
string.rfind(str, beg=0,end=len(string) ):类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。;
string.rindex( str, beg=0,end=len(string)):类似于 index()，不过是从右边开始.;
string.rjust(width,str):返回一个原字符串右对齐,并使用指定字符填充至width的长度的新字符串，默认空格填充;
string.rpartition(str):类似于 partition()函数,不过是从右边开始查找;
string.rstrip():删除 string 字符串末尾的空格.;
string.split(str="", num=string.count(str)):以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串;
string.splitlines([keepends]):按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。;
string.startswith(obj, beg=0,end=len(string)):检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.;
string.strip([obj]):在 string 上执行 lstrip()和 rstrip();
string.swapcase():翻转 string 中的大小写;
string.title():返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle());
string.translate(str, del=""):根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中;
string.upper():转换 string 中的小写字母为大写;
string.zfill(width):返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0;

>>> values=("cce",18)
>>> format="my name is %s and my age is %s" %values
>>> print(format)
my name is cce and my age is 18

>>> from string import Template
>>> tmpl=Template("My Name Is $name! and My Age Is $age")
>>> tmpl.substitute(name="cce",age=18)
'My Name Is cce! and My Age Is 18'

>>> print("My Name Is {} and my age is {}".format("cce",18))
My Name Is cce and my age is 18

>>> print("My Name Is {1} and my age is {0}".format(18,"cce"))  # 索引默认从0开始
My Name Is cce and my age is 18

>>> print("My Name Is {name} and my age is {age}".format(age=18,name="cce"))    
My Name Is cce and my age is 18

>>> fullname=['cce','cfj']
>>> print("cce name is {name[1]}".format(name=fullname))
cce name is cfj

>>> print("this box is {money:f} yuan".format(money=18))
this box is 18.000000 yuan

b：将整数表示为二进制数;
c：将整数解读为Unicode值;
d：将整数视为十进制数进行处理，这是整数默认使用的说明符;
e：使用科学表示法来表示小数(用e来表示指数);
E：与e相同，但用E来表示指数;
f：将小数表示为定点数;
F：与f相同，但对于特殊值(nan和inf)，使用大写表示;
g：自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符;
G：与g相同，但使用大写来表示指数和特殊值;
n：与g相同，但插入随区域而异的数字分隔符;
o：将整数表示为八进制数;
s：保持字符串的格式不变;
x：将整数表示为十六进制数并使用小写字母;
X：与x相同，但使用大写字母;
%：将数表示为百分比值;

>>> print("'{num:10}'".format(num=3))
'         3'
>>> print("'{name:10}'".format(name="Python"))
'Python    '

>>> print("'{num:.2f}'".format(num=3))
'3.00'

>>> print("'{num:10.2f}'".format(num=3))
'      3.00'

>>> print("'{num:,}'".format(num=(10*100000)))
'1,000,000'
>>> print("'{num:,.2f}'".format(num=(10*100000)))  
'1,000,000.00'

>>> print("'{num:010,.2f}'".format(num=(10*100)))
'001,000.00'
>>> print("'{num:010}'".format(num=(10*100)))    
'0000001000'

# 宽度为10，居左
>>> print("'{num:<10}'".format(num=(10*100)))   
'1000      '
# 宽度为10，居右
>>> print("'{num:>10}'".format(num=(10*100)))    
'      1000'
# 宽度为10，居中
>>> print("'{num:^10}'".format(num=(10*100))) 
'   1000   '
# 填充居中
>>> print("'{num:%^10}'".format(num=(10*100)))      
'%%%1000%%%'

print("test""test") # testtest
或
print("test"+"test") # testtest

# 直接使用str或者直接print，返回的值是用户易于看懂的值
print('Car') # Car
print(str('Car')) # Car

# repr 打印值，并保留其原来的样子
print(repr('Car')) # 'Car'

print('\name') # ame
print(r'\name') # \name