注释：单行：#……　　多行：单引号（’’’） 双引号（”””）

基本数据类型：整数：int；浮点数：float（只有这两种）；str：字符串；bool：布尔类型；complete：复数；list:列表；tuple:元组；set:集合；dict:字典

 1 >>> type(2)
 2 <class 'int'>
 3 >>> type(1.1)
 4 <class 'float'>
 5 >>> type(1+1.1)
 6 <class 'float'>
 7 >>> type(2/2)
 8 <class 'float'>
 9 >>> type(2//2)
10 <class 'float'>
11  >>> 2//2
12 1
13 >>> 2/2
14 1.0
15 >>> 2*2
16 4

基本类型

type()用来获取该表达式的数据类型

//:  除并取整

/ ：除之后商有一位小数

1 print("I", end=" ")
2 print("love ", end='')
3 print("you !")           # I love you !（没有换行）

进制转换

 1 >>> 0b10    # 二进制
 2 2
 3 >>> 0o10    # 八进制
 4 8
 5 >>> 0x10    # 十六进制
 6 16
 7 >>> bin(0o10)    # 八进制 转换 二进制
 8 '0b1000'
 9 >>> bin(10)       # 十进制 转换 二进制
10 '0b1010'
11 >>> bin(0x10)    # 十六进制 转换 二进制
12 '0b10000'
13 >>> int(0b10)     # 二进制 转换 八进制
14 2
15 >>> int(0o10)     # 十进制 转换 八进制
16 8
17 >>> int(0x10)     # 十六进制 转换 八进制
18 16
19 >>> hex(0b10)   # 二进制 转换 十六进制
20 '0x2'
21 >>> hex(0o10)   # 八进制 转换 十六进制
22 '0x8'
23 >>> hex(10)      # 十进制 转换 十六进制
24 '0xa'

进制转换

布尔类型

 1 # True和False首字母都要大写
 2 >>> type(True)
 3 <class 'bool'>
 4 >>> type(False)
 5 <class 'bool'>
 6 >>> int(True)
 7 1
 8 >>> int(False)
 9 0
10 >>> bool(1)
11 True
12 >>> bool(0)
13 False
14 >>> bool(2)
15 True
16 >>> bool(2.2)
17 True
18 >>> bool(-2)
19 True
20 >>> bool('abc')
21 True
22 >>> bool('')
23 False
24 >>> bool([1,2,3])
25 True
26 >>> bool([])
27 False
28 >>> bool({1,2,3})
29 True
30 >>> bool({})
31 False
32 >>> bool(None)
33 False
34 >>> 36j    # 输出复数
35 36j

布尔类型

str(不可变)：字符串 -> 单引号，双引号，三引号（成对出现）

 1 >>> "let's go !"
 2 "let's go !"
 3 >>> '''
 4 ... 1
 5 ... 2
 6 ... a
 7 ... b
 8 ... '''
 9 '\n1\n2\na\nb\n'
10 >>> "let's go !"
11 "let's go !"
12 >>> '''
13 ... 1
14 ... 2
15 ... a
16 ... b
17 ... '''
18 '\n1\n2\n3\na\nb\n'
19 >>> """\n1\n2\na\nb\n"""
20 '\n1\n2\na\nb\n'
21 >>> print("""\n1\n2\n3\na\nb\n""")
22 
23 1
24 2
25 3
26 a
27 b
28 
29 结束

str

format格式化函数

 1 >>> "{} {}".format("hello","world")    # 不设置指定位置，按默认顺序
 2 'hello world'
 3 >>> "{0} {1}".format("hello","world")    # 设置指定位置
 4 'hello world'
 5 >>> "{1} {0} {1}".format("hello","world")    # 设置指定位置
 6 'world hello world'
 7 >>> "网站名：{name}，地址：{url}".format(name="世界与你同在",url=" http://www.worldiwiu.ltd/main ")    # 设置参数
 8 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main '    
 9 >>> site = {"name": "世界与你同在", "url": " http://www.worldiwiu.ltd/main "}    # 通过字典设置参数
10 >>> "网站名：{name}，地址：{url}".format(**site)    # 通过**可讲字典中的值分配给关键字参数
11 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main '
12 >>> list = ['世界与你同在',' http://www.worldiwiu.ltd/main ']
13 >>> "网站名：{0[0]}，地址：{0[1]}".format(list)    # 通过列表索引设置参数；“0”是必须的
14 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main '

format格式化函数

关键字参数和默认值

像这样使用名称指定的参数称为关键字参数，只要有点是有足浴澄清各个参数的作用

 >>>store(patient=’Mr.Brainsample’,hour=10,minute=20,day=13,month=5) 

虽然这样做的输入量多些，但每个参数的作用清晰明了。另外，参数的顺序错了也没有关系，关键字参数最大的有点在于，可以指定默认值

 1 def hello_1(getting,name):
 2     print(‘{},{}!’.format(getting, name))
 3 >>>hello_1(name=’world’, getting=’Hello’)
 4 Hello,world!
 5 
 6 def hello_1(name,getting):
 7     print(‘{},{}!’.format(name, getting))
 8 >>>hello_2(getting=’Hello’, name=’world’)
 9 world,Hello!
10 
11 def hello_3(getting=‘Hello’,name=‘world’):
12     print(‘{},{}!’.format(getting, name))
13 # 参数设置默认值
14 >>>hello_3()
15 Hello,world!
16 >>>hello_3('I love', 'you ')
17 I love,you !
18 >>>hello_3(name='xing')
19 Hello,xing!
20 
21 def hello_4(name, getting='Hello', fuhao='!'):
22     print('{},{}{}'.format(getting, name, fuhao))
23 >>>hello_4('xing')
24 Hello,xing!
25 >>>hello_4('兴,今天过得好吗', getting='你好', fuhao='?')
26 你好,兴,今天过得好吗?

关键词参数和默认值

收集参数

 1 def print_params(*params):
 2     print(params)
 3 >>> print_params('Testing')
 4 ('Testing',)
 5 >>> print_params(1,2,3)
 6 (1, 2, 3)
 7 
 8 def print_params_2(title, *params):
 9     print(title, end="")
10     print(params)
11 >>>print_params_2('Params:', 1, 2, 3)
12 Params:(1, 2,3)# *:收集余下的位置参数
13 
14 def print_params_3(x, *y, z):
15     print(x, y, z)
16 >>>print_params_3(1, 2, 3, z=4)
17 1 (2, 3) 4
18 print_params_3(1, 2, 3, 4)
19 # 星号不会收集关键字参数
20 TypeError: print_params_3() missing 1 required keyword-only argument: 'z'
21 
22 # 要收集关键字参数,可使用两个星号
23 def print_params_4(**params):
24     print(params)
25 >>>print_params_4(x=1, y=2, z=3)
26 {'x': 1, 'y': 2, 'z': 3}
27 
28 def print_params_5(x, y, a, z=4, *pospar, **keypar):
29     print(x, y, z, a)
30     print(pospar)
31     print(keypar)
32 print_params_5(1, 2, 0, 3, 4, 5, 7, 6, foo=9, bar=8)
33 1 2 3 0
34 (5, 7, 6)
35 {'foo': 9, 'bar': 8}

收集参数

分配参数

1 def add(x, y):
2 return x + y
3 b=(2, 5)
4 print(add(*b))  # 显示: 7
5 # 这与前面的操作差不多是相反:不是收集参数,而是分配参数。这是通过在调用函数(而不是定义函数)时使用运算符*实现的
6 params = {'name': '兴', 'getting': '你好'}
7 hello_3(**params)     # 你好,兴!

分配参数

转义字符

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

1 >>> print(r'I\nlove\nyou')    # 加r之后，将输出原始字符串
2 I\nlove\nyou
3 >>> print('I\nlove\nyou')
4 I
5 love
6 you

字符切片

 1 >>> "hello word"[-0]
 2 'h'
 3 >>> "hello word"[0]
 4 'h'
 5 >>> "hello word"[2:5]
 6 'llo'
 7 >>> "hello word"[2:-1]
 8 'llo wor'
 9 >>> "I love you"[1]
10 ' '          # 空格也将会输出
11 >>> "I love you"[2:]
12 'love you'
13 >>> "I love you"[-3:]
14 'you'
15 >>> "I love you"[:-1]
16 'I love yo'
17 >>> "I love you"[:-0]
18 ''
19 >>> "I love you"[:0]
20 ''
21 >>> ["I","love","you"][1:]
22 ['love', 'you']
23 >>> ["I","love","you"][1:2]*3
24 ['love', 'love', 'love']
25 >>> type(["I","love","you"])
26 <class 'list'>
27 >>> (("I","love","you"))[1:]
28 ('love', 'you')
29 >>> "I love yuo I love you I love you"[2:15:3]
30 'leuIo'
31 >>> "I love yuo I love you I love you"[2::3]
32 'leuIo u vy'
33 # 2 :表示索引1；    15:表示索引2；    3 ：表示每隔三个输出一个字符
34 >>> "love" in ["I","love","yuo"]
35 True
36 # 表达式1  in  表达式 => 表达式1是否在表达式2中

字符切片

元组：( )    列表：[ ]    字典：{ }（无序的，没有索引，不可切片）

1 >>> type(set())    # 定义空的集合
2 <class 'set'>
3 >>> {1,2,3,4,5,6,7} - {3,4}    # 差集
4 {1, 2, 5, 6, 7}
5 >>> {1,2,3,4,5,6,7} & {3,4}    # 交集
6 {3, 4}
7 >>> {1,2,3,4,5,6,7} | {3,4}    # 并集
8 {1, 2, 3, 4, 5, 6, 7}

集合运算

位运算符

& -> 与

| -> 或

^ -> 异或

- -> 取反

<< -> 左移动

>> -> 右移动

int str tuple （不可变）值类型 list set dict（可变）引用类型

成员资格运算符  in    not in   测试该变量是否在该元组（列表、集合）中

相同运算符  is    not is   比较变量是否是同一个对象

 

如有错误或不足，请留言，谢谢！

本文链接：https://www.cnblogs.com/AI-Star-Java/p/11718743.html