python基础语法

1.vi技巧：
中英切换：shift
wq = x

2.注释
单行：#
多行：三个单引号或三个双引号

“”"
print(“hello world”)
“”"
1
2
3
3.编码
文件中有中文，不管是否为注释，python2执行报错。
解决：程序首行加 #coding=utf-8 或 #- coding:utf-8 -

4.输入
name = input(“请输入名字：”)
1
5.输出
print(“name is %s”%name)
print(“name:%s, age:%d”%(name,age))
print(“name:{0}, age:{1}”.format(name,age)) #(标号可不写，为默认顺序)
print(“name:{name}, age:{age}”.format(name = “ss”,age = 23))

import math
print(‘常量 PI 的值近似为 {0:.3f}。’.format(math.pi)) #常量 PI 的值近似为 3.142。

table = {‘Google’: 1, ‘Runoob’: 2, ‘Taobao’: 3}
print(‘Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}’.format(table))
#Runoob: 2; Google: 1; Taobao: 3

table = {‘Google’: 1, ‘Runoob’: 2, ‘Taobao’: 3}
print(‘Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}’.format(**table))
#Runoob: 2; Google: 1; Taobao: 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
6.类型转换
a = int(“3”)
1
7.python2与python3
编码。
python2中input的内容当做执行的内容，python3当做字符串。如a = input(“”). python2中的raw_input相当于python3中的inpout。
python2 中支持 <> 是不等于的意思，python3不支持，应该 != 表示
8.运算符
“a” * 5 = “aaaaa”
2 ** 3 = 8
5 / 2 = 2.5
5 // 2 = 2 #(取商)
5 % 2 = 1 #（取余）
1
2
3
4
5
9.逻辑运算符
and , or

10.流程
if 条件:
elseif 条件:
else:

while 条件:
执行
for i int str:
执行

注: i++,++i在python中不允许使用。
1
2
3
4
5
6
7
8
9
10
11.字符串(不可变)
类型转换：
int(“100”), str(100)
1
长度：
len(str)
1
字符串连接:
a = b + c #或者
a = “=%s=”%(b+c) #或者
a = “={}=”.format(b+c)
1
2
3
切片：
str = “dasfaf”
str[2:4] #(取得2到3的),
str[2:] #(到最后),
str[2?2] #(步长2，隔一个取一个)
1
2
3
4
逆序:
str = “abcdefABCDEF”
str[0:] # out:“abcdefABCDEF”
str[-1:] # out:“F”
str[-1:0] # out:""
str[-1:0:-1] # out:“FEDCBAfedcb”
str[-1::-1], str[::-1] # out:“FEDCBAfedcba”
1
2
3
4
5
6
常见操作
find: str.find(“abc”) # 从左向右有返回第一个匹配字符串的起始下标，没有返回-1。rfind():从右向左。
str.index(“abc”) #找到返回起始下标，没有抛出异常。 存在rindex().
str.count(“abc”) #匹配的个数。

str.replace(“abc”, “def”) #把左边的替换成右边的同java，
str.replace(“abc”, “def”,1) #第三个参数是从左到右替换个数。

str.split(" ") #同java
str.capitalize() #字符串的第一个字母大写。
str.title() #字符串的每个单词的首字母大写。
str.startswith(“abc”), str.endswith(“abc”) #同java.
str.lower() str.uper() #所有的字母小写和大写。
str.center(50) #居中显示，行总长50 " abc "
str.ljust(50), str.rjust(50) #左(右)对齐

str.lstrip() #删除左边空格
str.rstrip() #右边空格
str.strip() #删除两端空格.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
12.列表 (类似数组，可变，针对自身的变化)
[“zhangsan”,“lisi”]
#定义
names = [“zhangsan”, “lisi”, 3.14] #列表中的数据可以是不同的数据类型。 可以下标，和切片。
#增
names.append(“abc”) #–>插入到最后;
names.insert(0, “bcc”) #–>插入指定位置。

names = names1 + names2 #两个列表用连接符
names1.extend(names2) #扩充

#删
names.pop() #–>删除最后一个；
names.remove(“lisi”) #–>根据内容删除;
del names[0] #–>下标删除
#改
names[0] = “abc”
#查
name[1:] # “lisi”
in, not in #是否存在 （if “zhangsan” in names:）
#可以for… in 循环遍历

len(names) #元素个数

#注意：append添加的元素；extend连接的列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
运算符

表达式 结果 描述
len([1, 2, 3]) 3 计算元素个数
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 连接
[‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 复制
3 in [1, 2, 3] True 元素是否存在
for x in [1, 2, 3]: print(x, end=” “) 1 2 3 迭代
params = {“server”:“mpilgrim”, “database”:“master”, “uid”:“sa”, “pwd”:“secret”}
["%s=%s" % (k, v) for k, v in params.items()]
[‘server=mpilgrim’, ‘uid=sa’, ‘database=master’, ‘pwd=secret’]
“;”.join(["%s=%s" % (k, v) for k, v in params.items()])
‘server=mpilgrim;uid=sa;database=master;pwd=secret’
1
2
3
4
5
13.字典（可变）
a = {“name”:“yy”, “age”: 12}

#增
a[“name”] = “yy” #直接写key-value
#删
del a[“name”]
#改
a[“name”] = “zz” #相同key的值覆盖。
#查：
a[“name”], a.get(“name”)
1
2
3
4
5
6
7
8
9
10
for-else

#for中没有break,则else一定会执行
for temp in strs:
print(temp)
else:
print("")
1
2
3
4
5
const 修改变量为不可变。
字典常见操作

len(a) #键值对的个数

a.keys() #[“name”,“age”] (pyhton2) #dict_keys([“name”,“age”])(pyhton3)返回key的列表
if “abc” in a.keys(): #判断是否存在某个key
print("")
a.values() #返回value的列表
1
2
3
4
5
6
7
14.元组(类似列表，不可变)
列表可以增删改，元组不能改

tup1 = (); #空元组
1

tup1 = (50)
type(tup1) # 不加逗号，类型为整型

tup1 = (50,)
type(tup1) # 加上逗号，类型为元组

1
2
3
4
5
6
7
访问：

tup1 = (‘Google’, ‘Runoob’, 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0]) # Google
print ("tup2[1:5]: ", tup2[1:5]) #(2, 3, 4, 5)
1
2
3
4
5
修改：

tup1 = (12, 34.56);
tup2 = (‘abc’, ‘xyz’)

以下修改元组元素操作是非法的。

tup1[0] = 100

创建一个新的元组

tup3 = tup1 + tup2;
print (tup3) #(12, 34.56, ‘abc’, ‘xyz’)
1
2
3
4
5
6
7
8
9
删除

tup = (‘Google’, ‘Runoob’, 1997, 2000)

print (tup)
del tup;
1
2
3
4
运算符

表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
(‘Hi!’) * 4 (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print x, 1 2 3 迭代
类似拆包

a = (11,12)
b = a
b #out (11,12)
c,d = a #类似拆包
c #out 11
d #out 12

#例如
info = {“name”:“ysw”, “age”:24}
for temp in info:
print(temp)
#(“name”:“ysw”)
#(“age”:24)
for temp in info.items():
print(“key=%s,value=%s”%(temp[0],temp[1]))
#or
for a,b in info.items():
print(“key=%s,value=%s”%(a,b))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
遍历技巧：

#在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来
knights = {‘gallahad’: ‘the pure’, ‘robin’: ‘the brave’}
for k, v in knights.items():
print(k, v)

#gallahad the pure
#robin the brave

#在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到

for i, v in enumerate([‘tic’, ‘tac’, ‘toe’]):
… print(i, v)
…
0 tic
1 tac
2 toe

#同时遍历两个或更多的序列，可以使用 zip() 组合

questions = [‘name’, ‘quest’, ‘favorite color’]
answers = [‘lancelot’, ‘the holy grail’, ‘blue’]
for q, a in zip(questions, answers):
… print(‘What is your {0}? It is {1}.’.format(q, a))
…
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.

#要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数

for i in reversed(range(1, 10, 2)):
… print(i)
…
9
7
5
3
1

#要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值

basket = [‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’]
for f in sorted(set(basket)):
… print(f)
…
apple
banana
orange
pear

---

作者：ysw1132
来源：CSDN
原文：https://blog.csdn.net/ysw1132/article/details/79045714
版权声明：本文为博主原创文章，转载请附上博文链接！