python基本语法

发表于 | 分类于

基础语法

1. 注释

  • 单行注释：#号
  • 多行注释：'''和"""

2. 行与缩进

使用缩进来表示代码块，不需要使用大括号{}。同一个代码块的语句必须包含相同的缩进空格数

3. 多行语句

1
2
3
4
5
6
7
# 使用反斜杠(\)来实现多行语句
total = item_one + \
        item_two + \
        item_three
# 在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)  
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

4. 数字(Number)类型
python中数字有四种类型：整数、长整数、浮点数和复数。

  • int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  • bool (布尔),如 true。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数), 如 1 + 2j、 1.1 + 2.2j

5. 字符串(String)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# python中单引号和双引号使用完全相同。
word = '字符串'
sentence = "这是一个句子。"

# 使用三引号('''或""")可以指定一个多行字符串。
paragraph = """这是一个段落，
可以由多行组成"""

str='Runoob'

print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始的后的所有字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串

print('------------------------------')

print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

a = 'd' in 'bca'
print(a)                    # 返回False

6. 等待用户输入
input("\n\n按下 enter 键后退出。")
7. Print 输出

1
2
3
4
5
6
y="b"
# 换行输出
print( y )
print('---------')
# 不换行输出
print( y, end=" " )

8. import 与 from…import

1
2
3
4
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *

基本数据类型

1. 多个变量赋值

a,b,c = 1 ,3, 'sdf'

2. 标准数据类型

  • Number（数字）
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Sets（集合）

  • Dictionary（字典）

    type() 函数和isinstance()可以用来查询变量所指的对象类型

    1
    2
    3
    4
    a = 1
    # 返回 <class 'int'>
    isinstance(a, int)
    # 返回 True

    两者区别：

    • type()不会认为子类是一种父类类型。

    • isinstance()会认为子类是一种父类类型。

      注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

3. del语句
del语句删除单个或多个对象
del a
4. 次方计算
用**表示
2 ** 3返回8
5. List（列表）
list = [ 'abcd', 786 , 2.23, 'lightquant', 70.2 ]

与Python字符串不一样的是，列表中的元素是可以改变的。list[0] = a

6. Tuple（元组）
tuple = ( 'abcd', 786 , 2.23, 'lightquant', 70.2 )

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。

7. Set（集合）
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1
2
3
4
5
6
7
8
9
10
11
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
student2 = set('asd')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a和b的差集
print(a | b)     # a和b的并集
print(a & b)     # a和b的交集
print(a ^ b)     # a和b中不同时存在的元素

8. Dictionary（字典）
类似与java的map

  • keys()输出所有的key
  • values()输入所有的值
1
2
3
4
5
6
7
8
9
10
11
dict = {}
dict['one'] = "1 - 灯塔量化"
dict[2]     = "2 - lightquant"
 
tinydict = {'name': 'lightquant','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

9. Python数据类型转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# 1、int(n,base)函数
a = int('110',2)    # 二进制转换10进制，必须是字符串类型
b = int(3.6)        # 向下取整

# 2、float()  可是是字符串，也可以是数字，转换为浮点类型

# 3、complex() 函数 返回复数表达式（复数是什么？有什么用呢？）
complex(1, 2)   # return (1 + 2j)
complex(1)      # return (1 + 0j)
complex("1+2j") # return (1 + 2j)

# 4、str() 函数 将对象转化为适于人阅读的形式。
dict = {'light': 'lightquant.com', 'google': 'google.com'}
# return "{'light': 'lightquant.com', 'google': 'google.com'}"

# 5、repr() 函数 与str() 类似

# 6、eval() 函数
x = 2 ; eval('x * 2') # return 4

# 7、tuple()函数  将列表转换为元组。。

# 8、list()方法 将元组转换为列表。

# 9、dict() 函数 用于创建一个字典。

# 10、frozenset() 函数 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

# 11、chr() 函数 返回值是当前整数对应的ascii字符。
print chr(0x30) # return 0
print chr(48)   # return 0

# 12、ord() 函数 与chr()相反
print chr(0)    # return 0

# 13、hex() 函数 返回16进制

# 14、oct() 函数 返回8进制

# 15、除法计算
10 // 3 #等于3
10 / 3 #3.33333333333333

10. 数字格式化

1
2
3
4
5
6
7
8
9
10
11
12
 print("{:.2f}".format(3.1415926));     # 保留两位小数
 
 # {:+.2f} 带前缀'+'号
 # {:.0f}  不带小数
 # {:0>2d} 不足两位 ，前面补0
 # {:x<4d} 不足4位，后面补x
 # {:,}    逗号分隔数字，如：1,000,000
 # {:.2%}  保留两位小数，再加'%'后缀
'{:b}'.format(11)   # 二进制
'{:d}'.format(11)   # 十进制
'{:o}'.format(11)   # 八进制
'{:x}'.format(11)   # 十六进制

11. 字符串内建函数

1
2
3
str.capitalize()    # 首字符会转换成大写，其余字符会转换成小写。
str.center(10, '*') # 返回10位长度的字符串，前后用'*'补充
str.count('a',0,10) # 返回字符'a'在str出现的次数

集合

1、列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
list = ['Google', 'light', 1997, 2000]
list[2] = 2001  # 可以更新值
del list[2]     # 删除第三个参数

len([1, 2, 3])          # 返回长度
[1, 2, 3] + [4, 5, 6]   # 组合
['Hi!'] * 4             # 重复
3 in [1, 2, 3]          # 判断该列表中是否存在某个数
for x in [1, 2, 3]:     # 遍历
    print(x, end=" ")   

#######函数########
len(list)               # 列表长度
max(list);min(list)     # 最大值 最小值
list(seq)               # 将元组转换为列表
list.append(obj)        # 在列表末尾添加新的对象
list.count(obj)         # 统计某个元素在列表中出现的次数
list.extend(seq)        # 相当于java的addAll(list);
list.index(obj)         # 找出字符下标 ，没有找到会报错
list.insert(index, obj) # 插入数据
list.pop(i)             # 默认删除最后一个，返回删除的值
list.remove(obj)        # 删除匹配的第一个值，没有匹配会报错
list.sort(l)            # 排序
list.clear()            # 清空列表
list.copy()             # 复制

2、元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
tup1 = ('Google', 'light', 1997, 2000);
tup1 = ();              # 创建空元组


## 1. 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
tup1 = (50) ; tup2 = (50,)  # tup1是整数类型，tup2才是元祖 

## 2. 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3)

## 3. 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
del tup;

## 4. 将列表转换为元组。
tuple(list1)

3、字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
d = {key1 : value1, key2 : value2 }
## 键必须是唯一的，但值则不必。

del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

## 不允许同一个键出现两次。创建时如果同一个键被赋值两次，会以后面的为准
## 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

b = a.fromkeys(seq)     # 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key, 'default')    #没有就返回'default'，或者None
dict.items()            # 遍历返回

dict.setdefault(key, 'default')     
# 如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。

dict.update(dict2)      # dict2 -- 添加到指定字典dict里的字典。
pop(key[,default])      #  返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()               # 随机返回并删除字典中的一对键和值(一般删除末尾对)
lightquant wechat
欢迎您订阅灯塔量化公众号！