python 速成笔记 [基础语法 一]

发表于 | 更新于: | 分类于
字数统计: 6,773 | 阅读时长 ≈ 28

0x01 理解机器码,字节码的基本概念:

1
2
低级语言:  汇编 C 
=> 机器码 [直接可以丢给cpu去执行]
1
2
3
高级语言:  
Java ruby python c# php[应用场景非常局限,只限于web开发] C++ ...
=> 字节码 [通常是个二进制文件(python中是.pyc文件),也叫中间代码,还需要对应的各类语言的解释器进一步转换成机器码才能直接被cpu执行]

0x02 了解 python 的一些常见种类:

1
2
3
4
C    python	c语言版 python	默认大家所说的python一般都是指C python
J    python	java版  python
iron python	C#版 	python
...

0x03 不同python版本号间的一些区别:

1
2
3
python 2.6  属于过度版本
python 2.7  也属于过度版本,2020年后将不再被支持
python 3.5  属于重大改进后的版本

0x04 不同版本间的语法区别样例

1
2
3
部分函数名称变更,底层执行效率提升,如下,简单的事例
print "hello python2.7"  2.x 的输出写法
print("hello python3.x") 3.x 的输出写法

0x05 python 解释器自身的工作细节:

1
读取并执行文件中的python代码 -> 转换成对应的字节码 -> 再转换成机器码 -> 到cpu上执行

0x06 执行python代码的两种方式:

直接通过代码文件执行:

1
2
python 源代码文件通常以.py结尾的,但这并不是必须的
指定python解释器位置,指定要执行的python代码文件位置 如,c:\python36\python.exe d:\demo.py 语法没有错误的前提下,即可被成功执行

进入python解释器下执行python代码:

1
2
3
4
5
C:\Program Files\Python36>python.exe
Python 3.6.0 (v3.6.0:41df79263a11, Dec 23 2016, 08:06:12) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("hello python3.6")
>>> exit()

0x07 最基础的计算机编码常识:

1
2
ascii码,这也是最开始的字符表示方式
只需占1个字节,即8位,2的8次方等于256,完全可以把键盘上所有的英文字母和数字,特殊字符都表示完

1
2
汉语字符集的大致发展历程
GB2312 -> GBK -> GB18030 -> unicode
1
2
3
4
了解 unicode 编码 [ 万国码 ]
统一占两个字节,一上来就占16位
另外,我们知道在unicode编码中一个汉字要占三个字节,也就是说还多出一个字节的空间被浪费了
同样,像字母这种不足16位的,也是按16位的大小来存,缺点已经显而易见了,浪费空间,所以后来就优化出了utf-8编码
1
2
3
utf-8编码
属基于unicode优化后的编码,对于英文,字母和特殊字符,全部用8位表示,中文则用24位
针对不同的字符给不同的大小,实现自动变长,合理利用资源,基本支持全球大部分国家的语言

0x08 不同的python版本对编码的处理:

1
2
python 2.x 默认使用ascii编码,如果有中文,则需要事先手工指定编码
python 3.x 默认unicode编码,所以基本无需太关注编码问题

比如,在 python 2.x 代码中使用中文就必须事先代码文件头部,指定好字符集,如下:

1
# -*- coding:utf-8 -*-

在python2.7中手工处理win cmd输出中文乱码

1
2
utf-8 到 gbk  unicode[万国码]相当于中间人 
先把utf-8解码成unicode,再把unicode编码成gbk,下面就是具体的代码编码和解码流程

1
2
3
4
5
6
7
#!/usr/bin/python2.7
# --*-- coding:utf-8 --*--

stri = 'python 的创始人是吉多·范罗苏姆'
dec_stri = stri.decode('utf-8')
in_stri = dec_stri.encode('gbk')
print in_stri

如果是在python 3.x中,win cmd是不用手工编码再解码的,在python 3.x内部就已经帮我们把编码处理好了

1
2
3
#!/usr/bin/python3.5
stri = 'python的创始人为吉多·范罗苏姆'                                                                            
print(stri)

0x09 python 中的注释:

1
2
3
4
5
6
7
8
9
单行注释 # 要注释的内容
多行注释,单双引号均可,在python中单双引号作用完全相同,不存在强弱引用之别,跟其它语言稍有差别
'''
   要注释内容...
'''
""" 
   要注释内容...
"""
python 语句结束不需要分号,代码块对应关系全部以缩进来区分,格式要求很严格,非常规整

0x10 到底什么叫声明变量:

1
就是一段存在指定内存地址上的数据,根据变量名可以快速找到这段数据,仅此而已

0x11 在python中声明变量及变量命名规则须知 [和其它语言并无差别]:

变量名 必须由大小写字母,下划线,数字组成,但不能以数字开头,另外,禁止使用python各种内置关键字作为变量名,如下,

1
2
3
4
username = "klion"
password = "admin"
username_new = username 支持变量直接再赋给变量 
del username 		手动销毁变量,其实python内部也会自动回收没有指向的内存空间,又名垃圾回收机制

0x12 熟练掌握 python中的一些基本数据类型,因为python本身是纯面向对象的,所以每种数据类型对应的其实就是一个类,把某个值赋给某个变量的过程其实就相当于根据这个数据类型所对应的类创建一个对象:

1] 数字类型,关键字 int , 注意,在python3.x中对于数字型并没有长度限制,python2.x 有长度限制

熟练使用数字类型的一些常用方法:

1
2
3
4
5
int()
把一个字符串强制转换成一个数字,前提是要转换的这个字符串必须全部是由纯数字组成
 
num = int("1234")
print(type(num))

1
2
3
4
5
6
int(num,base=2)
把num字符串按照指定的进制数转换成十进制,2表示二进制,8表示八进制,16表示16进制,默认是转10进制的

num = "0011"
res = int(num,base=2)
print(res)
1
2
3
4
5
bit_length 输出指定数字所占的有效二进制位数,

num = int("3")
res = num.bit_length()
print(res)
1
2
3
4
5
6
__add__ 比较简单,就是将两个数相加

num = int("3")
num1 = 34
res = num.__add__(num1)
print(res)

2] 字符串类型,关键字 str

1
2
3
4
5
定义一个字符串:
单引号 'str'
双引号 "str"
三引号 """ str """ 跟注释的区别就在于有没有变量接收,没有接收就是注释,有接收就是字符串变量
字符串连接符 ' + '

熟练使用字符串的一些常用内置方法:

1
2
3
len() 	统计字符串或者列表[以逗号分割]长度
str_info = "Hello klIon ^_^! hEllo KittY"
print(len(str_info))

通过字符串索引 取值,切片

1
2
3
4
5
6
str_info = "Hello klIon ^_^! hEllo KittY"

print(str_info[0])		取第一个字符
print(str_info[2:6])		取第三个到第7个字符,大于等于2小于6
print(str_info[9:-1])		取第10个到倒数第一个之间的所有字符
print(str_info[12:-2])		取第13个到倒数第二个之间的所有字符

循环取出字符串中所有的字符及其对应的索引

1
2
3
4
5
6
7
8
9
str_info = "Hello klIon ^_^! hEllo KittY"
print(len(str_info))
iterm = 0
while iterm < len(str_info):
	print(iterm,"=>",str_info[iterm])
	iterm += 1

for iterm in str_info:
	print(iterm)

1
2
3
4
5
"分隔符".join(要拆分拼接的字符串)    
将指定的字符串按照指定的分割符进行拼接,返回一个新字符串

str_info = "hello linux"
print("*".join(str_info))
1
2
3
4
5
split('分隔符',分割次数)  
按照指定字符和分割次数进行分割,默认是从左到右分割,分割后返回一个的新列表,注意,分隔符本身并不包含在内

str_info = "this is a test demo code ! thanks "
print(str_info.split('t',2))
1
2
3
4
5
rsplit('分隔符',分割次数)  
指定字符分割和分割次数,从右到做开始分割,同样返回一个新列表

str_info = "this is a test demo code ! thanks "
print(str_info.rsplit('t',2))
1
2
3
4
5
6
partition('指定要切割的字符')  
以指定的字符进行切割,不同于split的是,它只切割一次,也就是说当遇到第一个要切割的字符就是开始切割
后面再遇到该字符就不再切割了,返回一个切割后的元祖,默认是从左到右进行切割的

str_info = "hello klion ^_^! hello kitty"
print(str_info.partition('l'))
1
rpartition('指定要切割的字符') 以指定的字符进行分割,从右往左开始
1
2
3
splitlines([False/True])以换行符进行分割,返回一个新列表,如果加上True则保留\n,否则则不保留
str_info = "this is a test \ndemo code ! thanks "
print(str_info.splitlines())
1
2
3
4
5
replace('要替换的内容[旧]','要替换成的内容[新]',要替换的次数[默认替换所有]) 
把旧字符串替换成新字符串,默认是从左到右进行替换的,返回一个替换后的新字符串

str_info = "welcome to klion "
print(str_info.replace('klion','linux',1))
1
2
3
4
5
find('字符序列',字符串索引起始位置,字符串索引结束位置) 
寻找指定的子序列在目标字符串中是否存在,默认是按照从左往右的顺序查找,查到则返回对应字符序列在目标字符串中的索引位置,查不到则返回-1

str_info = "welcome to klion,klion is a pentester! "
print(str_info.find('sec',0,100))
1
rfind('字符序列',字符串索引起始位置,字符串索引结束位置)  和find不同的是,find默认是从左开始查找的,而rfind是从右开始查找的
1
2
3
4
5
strip(指定要剔除的字符[应该是遍历循环剔除的,只要匹配到其中任意一个字符就剔掉])
默认是剔除指定字符串两边的空白符[空格],亦可指定要剔除的指定字符,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.strip('w**'))
1
2
3
4
5
lstrip(指定要剔除的字符)  
默认是剔除指定字符串左侧的空白符,亦可指定要剔除的指定字符,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.lstrip('w**'))
1
2
3
4
5
rstrip(指定要剔除的字符)  
默认是剔除右边的空白符,亦可指定要剔除的指定字符,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.rstrip('w**'))
1
2
3
4
upper()  把指定字符串全部转换成大写,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.upper())
1
2
3
4
isupper() 判断目标字符串是否全部为大写,全部为大写则返回True,否则返回False

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.isupper())
1
2
3
4
lower()  把指定字符串全部转换为小写,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.lower())
1
2
3
4
islower() 判断目标字符串是否全部为小写,全部为小写则返回True,否则返回False

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.islower())
1
2
3
4
casefold()将目标字符串全部转换成小写,会返回一个新的字符串,常用

str_info = "Hello klIon ^_^! hEllo Kitty"
print(str_info.casefold())
1
2
3
4
5
count('字符序列',目标字符串起始索引位置,目标字符串结束索引位置)
统计某个字符序列在目标字符串中出现的次数,返回总共匹配到次数

str_info = "welcome to klion,klion is a pentester! "
print(str_info.count('klion',0,100))
1
2
3
4
isdecimal() 检查目标字符串是否为十进制字符[其实就是指整数],是则返回True,反之,则返回False,实际中用的较多

str_info = "3"
print(str_info.isdecimal())
1
2
isnumeric() 检查目标字符串是否为纯数字,用法同上,是则返回True,否则返回False
isalnum() 检查目标字符串是否为纯数字或字母组成,是则返回True,否则返回False
1
2
3
4
isspace() 检查目标字符串是否为空格,是则返回True,否则返回False

str_info = " "
print(str_info.isspace())
1
2
3
4
isalpha() 目标字符串是否为纯字母,是则返回True,否则返回False

str_info = "pentester"
print(str_info.isalpha())
1
2
3
4
isprintable检查目标字符串中是否存在不可见字符,如tab,空格...,是则返回True,否则返回False

str_info = "hello klion ^_^!"
print(str_info.isprintable())
1
2
3
4
5
6
用于接收的变量[pattern] = maketrans('要替换的内容','替换成的内容') 有点儿类似linux中的tee命令,需要配合translate()一起使用
translate(pattern) 

pattern = maketrans('A-XY-Za-xy-z', 'C-ZA-Bc-za-b')
str = "this is a convert....la!!!";
print(str.translate(trantab))
1
2
3
4
5
6
title把目标字符串转换成标题样式,返回一个新的字符串
istitle 判断目标字符串是否为标题格式 [标题的每个单词首字母一般都会大写],是则返回True,否则返回False

str_info = "hello klion ^_^!"
t_res= str_info.title()
print(t_res.istitle())
1
2
3
4
ljust(要填充到的长度,用来填充的字符)   字符串填充,从右边开始填充

str_info = "hello klion ^_^!"
print(str_info.ljust(30,'#'))
1
2
3
4
rjust(要填充的长度,用来填充的字符)   字符串填充,从右边开始填充

str_info = "hello klion ^_^!"
print(str_info.rjust(30,'#'))
1
2
3
4
5
6
center(要填充到的长度,"要填充的内容") 
填充居中,返回一个新字符串

str_info = "hello klion ^_^!"
res = str_info.center(30,"#")
print(res)
1
2
3
4
capitalize()  让整条语句首字母大写

str_info = "hello klion ^_^! hello kitty"
print(str_info.capitalize())
1
2
3
4
endswith() 判断目标字符串是否以指定字符结尾

str_info = "Hello klIon ^_^! hEllo KittY"
print(str_info.endswith('Y',21))
1
2
3
4
startswith() 判断目标字符串是否以指定字符开头

str_info = "Hello klIon ^_^! hEllo KittY"
print(str_info.startswith('H',0))
1
2
3
4
expandtabs(32) 把tab键替换成指定个数的空格,例如,下面可以直接利用此方法输出成表格的形式

str_info = "name:sec\tmail:sec@sec.org\tage:23\nname:sec\tmail:sec@sec.org\tage:23\nname:sec\tmail:sec@sec.org\tage:23\n"
print(str_info.expandtabs(32))

布尔类型,关键字 Bool [务必注意开头要大写]

1
2
True (真),1
False(假),0

为真的情况就不说了,只说为假的情况,如下:

1
2
3
4
5
None
""  空字符串
()  空元祖
[]  空列表
{}空字典

3] 列表 list,以’[]’表示,以英文逗号对列表中的每个元素进行分割,列表中的元素可以是任意数据类型,并支持随意的增删改查及in操作,列表是有序的

1
2
3
li = list()  创建空列表
list_info = ['klion','25','sec@sec. org','hello ','5324213','num','pentester','kali']
list_tmp  = ['num',23]

依然是通过 索引,切片取值,跟字符串用法基本是一样的,切完以后会返回一个新列表

1
print(list_info[3:-1])

for循环取出列表中的所有元素

1
2
3
print(len(list_info))# len() 方法用来统计列表元素个数
for iterm in list_info:
	print(iterm)

1
2
index('目标列表中的某个元素值',起始索引位置,结束索引位置)返回某个元素在目标列表中的索引数值
print(list_info.index('pentester'))
1
2
3
4
insert(指定要插入到的索引位置,'要插入的内容')往原有列表中插入新数据,会直接改变原有列表
res = list_info.insert(5,'security')
print(list_info)
print(res)
1
2
3
4
append(要追加的元素) 往现有的列表里面里面追加一个新的列表项,把参数的整体作为一个列表元素
res = list_info.append(list_tmp)
print(list_info)
print(res)
1
2
3
4
extend(另一个列表)  通常用于将两个列表合并成一个列表,例如:字符串,列表,元祖,字典
res = list_info.extend(list_tmp)
print(list_info)
print(res)
1
2
3
4
pop(指定要删除的元素索引值)删除指定的元素,会返回被删除的这个元素的值
res = list_info.pop(3)
print(list_info)
print(res)
1
2
3
4
remove(直接指定列表中的某个元素) 移除指定的元素,同样会直接改变原有列表
res = list_info.remove('kali')
print(list_info)
print(res)
1
2
3
4
reverse() 反转列表元素,会直接改变原有列表
res = list_info.reverse()
print(list_info)
print(res)
1
2
3
4
sort()  对列表中元素进行排序,默认升序
res = list_info.sort()
print(list_info)
print(res)
1
2
3
4
clear()   清空列表,单单只是清空列表项,并非删除该列表
res = list_info.clear()
print(list_info)
print(res)
1
2
3
copy() 把列表拷贝一份,属于浅拷贝
new_list = list_info.copy()
print(new_list)
1
2
3
4
count() 统计某个元素在列表中出现的次数
res = list_info.count('num')
print(list_info)
print(res)
1
2
3
4
把列表批量替换成字符串,如果列表中只有字符串,可以''.join(list) 自动循环拼接,如下,
list_info = ['sec','ok','connect']
str_res = '-'.join(list_info)
print(str_res)
1
2
3
4
5
6
列表中既有字符串又有字符串则需要自己写循环,循环强制str转换成字符串再进行拼接
str_tmp = ''
list_info = ['sec',34,'ok','connect','login','succeed',110]
for iterm in list_info:
	str_tmp += str(iterm)
print(str_tmp)
1
2
3
多层嵌套取值
list_info = ['klion',[1,2,3,4,5,['k','23','this']],'sec@sec. org','hello ','5324213','num','pentester','kali']
print(list_info[1][5][1])

in 及 not in 操作

1
2
3
4
if 'klion' in list_info:
	print('yeah is inter! ')
else:
	print('Oh No!')

1
2
3
4
5
if 'xlion' not in list_info:
	print('yeah is outer! ')
else:
	print('Oh No!')
`

4] 元祖类型,关键字,tuple,用’()’表示,内部一级元素是不可修改的,也就是说对一级元素项不可以增删改查,俗称,’只读列表’,但对于元素项中的子列表是可以修改的,习惯性的在元祖最后多加个逗号,元祖也是有序的

同上,通过索引,切片取值,多层嵌套取值,常用方法,如下:

1
2
count(指定要统计次数的元素) 统计某个
index(指定要获取索引的元素) 获取某个元素的索引位置

1
2
3
4
5
6
7
8
tuple_res = ('ok','connect',110,'status','login',110,'succeed',[1,2,3,('yeah','here','linux',[23,5,354,23],),5],)
print(tuple_res)
print(tuple_res[0])
print(tuple_res[3:6])
print(tuple_res[2:5])
print(tuple_res.count(110))
print(tuple_res.index('connect'))
print(tuple_res[7][3][3][2])
1
2
for iterm in range(len(tuple_res)):
	print(iterm,'=>',tuple_res[iterm])

5] 列表和元祖的一点区别:

1
元祖和列表本质几乎是一模一样的,但元祖中的一级元素是不允许修改的而列表中的元素都是可以被随意修改的

6] 字典类型,关键字 dict,用’{key->value}’表示,里面的value可以是任意类型的数据,key可以是数字,字符串,元祖,但它只有索引,不能切片,字典是无序的,默认for循环只有key,另外,元祖,列表,字典可以相互嵌套,类似php中的’数组’

1
2
3
4
5
6
7
8
9
10
11
12
dict_info = {
	'name':'klion',
	'age' :'26',
	'email':'sec@sec.org',
	'phone':'12334213',
	'list_info' : {
		'a':12,
		'b':13,
		'c':14
	},
	'city':['bj','ne','ko','to']
}

字典是根据键取值的

1
2
print(dict_info['email'])
print(dict_info)

字典常用的一些内置方法:

1
2
3
get(指定目标字典的key) 取出字典中的某个key对应的值,如果key不存在返回None
gets = dict_info.get('age')
print(gets)

1
2
3
4
pop() 删除字典中指定的值
dels = dict_info.pop('phone')
print(dels)
print(dict_info)
1
2
3
keys() 把目标字典中的所有键取出来放到一个新的字典中
keys = dict_info.keys()
print(keys)
1
2
3
values()把目标字典中的所有值取出来放到一个新的字典中
values = dict_info.values()
print(values)
1
2
3
items()把目标字典中的所有键值取出来放到一个新的字典中
items = dict_info.items()
print(items)
1
2
3
clear()清空目标字典,单单只是清空并不是删除
nulls = dict_info.clear()
print(nulls)
1
2
3
4
update()更新某个键的值
new_age = dict_info.update({'name':'sec','age':'45'})
print(new_age)
print(dict_info)
1
2
3
fromkeys()  根据指定的key生成一个统一值的字典
allkey = dict_info.fromkeys(['name','linces','tmp_num'],18)
print(allkey)

7] 集合类型,关键字 set,由不同元素组成,且必须为不可变类型,即字符,数字,元祖,默认是无序的,另外,内部会自动去重

定义一个集合

1
2
s = {1,2,3,4,5,'klion','sec@sec.org','sec','klion','kali',4,'wow'}
p = {3,5,'sec','nuddle','backbox','fedora'}

1
2
3
add() 向集合中添加元素
s.add('linux')
print(s)
1
2
3
copy()  将集合复制一份
new_set = s.copy()
print(new_set)
1
2
3
pop()  随机删除集合中的一个元素
s.pop()
print(s)
1
2
3
clear() 清空集合中所有的元素,并非删除集合本身
s.clear()
print(s)
1
2
3
remove() 删除集合中指定的某个元素,如果没有该元素,会报错
s.remove('klion')
print(s)
1
2
3
discard() 删除集合中指定的元素,如果没有该元素,不会报错,常用
s.discard('xlion')
print(s)

集合中常用的一些内置方法

1
2
3
4
s_n = set(s)
p_n = set(p)
print(s_n)
print(p_n)

1
2
交集 intersection() 或者 &  取出两个集合中的共同部分
print('交集',s_n&p_n)
1
2
并集 union() 或者 |把两个集合中的所有元素去重合并
print('并集',s_n|p_n)
1
2
差集 difference() 或者 -  取出s_n中p_n没有的元素
print('差集',s_n-p_n)
1
2
补集 symmetric_difference() 或者 ^ 把两个集合合并然后抠除共有元素,留下剩余部分
print('补集',s_n^p_n)

0x13 python 基本数据类型小结:

1
2
对于字符串而言,执行一个功能,都会产生一个新的字符串
对于list,tuple,dic,执行一个方法,大多都是直接更新自身

0x14 python 常用的一些运算符:

1
2
算数运算符[ 乘除取余优先级高于加减 ]
+(加) -(减) *(乘以) /(除) //(直接取整,并非四舍五入) %(取余) **(x**y 表示x的y次方)

1
2
3
4
5
6
7
8
9
注意:
如果想在2.7中如果想让9/2输出结果为4.5就必须先引入下面的模块
from __future__ import division   

python 2.7 
9/2 = 4

python 3.x
9/2 = 4.5
1
2
赋值运算符
= += -= *= /= %= **= //=
1
2
比较运算符(只返回真假)
==(等于) !=(不等于) <>(不等于,相当于!=) >(大于) <(小于) >=(大于或者等于) <=(小于或等于)
1
2
3
4
5
6
7
8
9
10
逻辑运算符 [ not的优先级最高,平时自己写代码时,最好把逻辑运算都加上括号 ]
and(且) or(或) not(非)

如果有连续多逻辑运算操作且没加括号,则严格按照从左到右一个个计算,总结规律如下 
真 遇到 or 最终结果肯定为真
假 遇到 and 最终结果肯定为假

短路原则
and 前面一个条件为假,后面就不再计算了
or 前面条件如果为假,后面继续计算
1
2
3
4
5
成员运算符(专门用来寻找一个字符串是否在另一个字符串里面),返回布尔值
in 
not in
字符 in 字符串  	判断某个字符或字符序列是否在某个字符串中
字符 not in 字符串  判断某个字符或字符序列是否不在某个字符串中
1
2
3
三元运算符
值1[成立] if 条件 else 值2[不成立]
True if id > 1 else False

0x15 python中常用的一些辅助方法:

1
2
3
4
5
type() 	查看某个变量的数据类型
id() 	查看变量在内存中的地址
help(type(变量))
dir(变量)
input() 凡是从input中输入的内容默认都是字符串类型的,如果输入的是字符串数字则需要自己手工用int强制转换下

0x16 python 流程控制格式:

条件判断:

1
2
3
4
5
6
单分之判断:
if 条件:
	条件成立,执行此语句
	条件成立,执行此语句 [ 注意缩进必须一一对应 ]
else:
	条件不成立,执行此语句

多分之:

1
2
3
4
5
6
7
8
if 条件一:
	条件成立,执行此语句
elif 条件二:
	条件成立,执行此语句
elif 条件三:
	条件成立,执行此语句
else:
	条件不成立,执行此语句[ pass表示什么都不做 ]

循环控制:

1
2
while 条件[每执行完一次回来看下条件是否还满足,如果满足就继续循环,知道不满足退出循环,务必谨记在最后给退出条件]:
	要循环的语句

1
2
3
4
while 条件: 
	....
else: 当上面的条件都不成立时则执行此代码块中语句,只会执行一次
	....
1
break 跳出当前整个循环,且后面的代码不再执行
1
continue 只跳出当前这一次的循环,继续下一次循环
1
2
3
4
for 变量 in 条件:
	要循环的语句
else:
	上面的循环被正常执行完,也就是中间没有任何break或者continue,才会执行else里面的东西
1
2
3
4
range(起始值,总数,每次迭代的步长)
可专门用来获取指定范围内的数,默认是0开始的
for iterm in range(0,10,2):
	print(iterm)
1
2
3
4
enumrate(可迭代的对象,起始位置[默认从0开始]) 会把这个可迭代对象的索引及索引对应的值一一遍历出来,如下,前面是索引,后面是索引对应的值
li = ['redhat','debian','feodra','parrot','backbox','kali','alex','sec']
for iterm,fix in enumerate(li):
	print(iterm,fix)

0x17 在python钟对字符串进行格式化输出:

第一种[百分号]:

1
2
3
%s 代表字符串,但它基本所有类型都能接收,用的最多,一般都用这个
%d 代表数字,也就是说它只能接受整形
%f 只能接收小数,浮点数,默认加6位的精度

1
2
3
4
5
common_out = 'Work hard to move yourself %s, work hard to do nothing, you will succeed %d' % ('klion',100)
common_out = 'Work hard to move yourself %(name)s, work hard to do nothing, you will succeed %(num)d' % {'name':'sec','num':33}
common_out = 'Work hard to move yourself %s, work hard to do nothing, you will succeed %.3f' % ('klion',1234.23123123)
common_out = 'Work hard to move yourself %s, work hard to do nothing, you will succeed %d%%' % ('klion',100)
print(common_out)

第二种[format方式]:

1
2
3
4
5
6
:d 整数
:s 字符串
:f 浮点型
:b 二进制输出
*  代表直接传列表
** 代表直接传字典

1
2
3
format_out = 'Work hard to move yourself {name}, work hard to do nothing, you will succeed {num}'.format(name='sec',num=123)
format_out = 'Work hard to move yourself {name}, work hard to do nothing {mail}, you will succeed {num}'.format(**{'name':'security','num':123,'mail':'sec@sec.org'})
print(format_out)

后话:
    当你真正熟练掌握了一门脚本语言之后,再去学另一门脚本语言,其实上手用起来是很快的,这些基础语法正常情况下半天就应该搞定了

0%