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

低级语言: 汇编 C 
=> 机器码 [直接可以丢给cpu去执行]

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

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

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

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

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

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

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()

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

汉语字符集的大致发展历程
GB2312 -> GBK -> GB18030 -> unicode 

了解 unicode 编码[万国码]
统一占两个字节,一上来就占16位
另外,我们知道在unicode编码中一个汉字要占三个字节,也就是说还多出一个字节的空间被浪费了
同样,像字母这种不足16位的,也是按16位的大小来存,缺点已经显而易见了,浪费空间,所以后来就优化出了utf-8编码

utf-8编码
属基于unicode优化后的编码,对于英文,字母和特殊字符,全部用8位表示,中文则用24位
针对不同的字符给不同的大小,实现自动变长,合理利用资源,基本支持全球大部分国家的语言

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

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

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

#!/usr/bin/python2.7
# --*-- coding:utf-8 --*--

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

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

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

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

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

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

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

int(num,base=2) 把num字符串按照指定的进制数转换成十进制,2表示二进制,8表示八进制,16表示16进制,默认是转10进制的
num = "0011"
res = int(num,base=2)
print(res)

bit_length 输出指定数字所占的有效二进制位数,
num = int("3")
res = num.bit_length()
print(res)

__add__ 比较简单,就是将两个数相加
num = int("3")
num1 = 34
res = num.__add__(num1)
print(res)

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

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

通过字符串索引 取值,切片
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个到倒数第二个之间的所有字符

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

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)

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

str_info = "hello linux"
print("*".join(str_info))

split(‘分隔符‘,分割次数) 
按照指定字符和分割次数进行分割,默认是从左到右分割,分割后返回一个的新列表,注意,分隔符本身并不包含在内

str_info = "this is a test demo code ! thanks "
print(str_info.split(‘t‘,2))

rsplit(‘分隔符‘,分割次数) 
指定字符分割和分割次数,从右到做开始分割,同样返回一个新列表

str_info = "this is a test demo code ! thanks "
print(str_info.rsplit(‘t‘,2))

partition(‘指定要切割的字符‘) 
以指定的字符进行切割,不同于split的是,它只切割一次,也就是说当遇到第一个要切割的字符就是开始切割
后面再遇到该字符就不再切割了,返回一个切割后的元祖,默认是从左到右进行切割的

str_info = "hello klion ^_^! hello kitty"
print(str_info.partition(‘l‘))

rpartition(‘指定要切割的字符‘) 以指定的字符进行分割,从右往左开始

splitlines([False/True])    以换行符进行分割,返回一个新列表,如果加上True则保留\n,否则则不保留
str_info = "this is a test \ndemo code ! thanks "
print(str_info.splitlines())

replace(‘要替换的内容[旧]‘,‘要替换成的内容[新]‘,要替换的次数[默认替换所有]) 
把旧字符串替换成新字符串,默认是从左到右进行替换的,返回一个替换后的新字符串

str_info = "welcome to klion "
print(str_info.replace(‘klion‘,‘linux‘,1))

find(‘字符序列‘,字符串索引起始位置,字符串索引结束位置) 
寻找指定的子序列在目标字符串中是否存在,默认是按照从左往右的顺序查找,查到则返回对应字符序列在目标字符串中的索引位置,查不到则返回-1

str_info = "welcome to klion,klion is a pentester! "
print(str_info.find(‘sec‘,0,100))

rfind(‘字符序列‘,字符串索引起始位置,字符串索引结束位置) 和find不同的是,find默认是从左开始查找的,而rfind是从右开始查找的

strip(指定要剔除的字符[应该是遍历循环剔除的,只要匹配到其中任意一个字符就剔掉])    
默认是剔除指定字符串两边的空白符[空格],亦可指定要剔除的指定字符,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.strip(‘w**‘))

lstrip(指定要剔除的字符) 
默认是剔除指定字符串左侧的空白符,亦可指定要剔除的指定字符,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.lstrip(‘w**‘))

rstrip(指定要剔除的字符) 
默认是剔除右边的空白符,亦可指定要剔除的指定字符,返回一个新的字符串

str_info = "***welcome to klion,klion is wa pentester!***w"
print(str_info.rstrip(‘w**‘))

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

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

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

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

casefold()    将目标字符串全部转换成小写,会返回一个新的字符串,常用    
str_info = "Hello klIon ^_^! hEllo Kitty"
print(str_info.casefold())

count(‘字符序列‘,目标字符串起始索引位置,目标字符串结束索引位置),统计某个字符序列在目标字符串中出现的次数,返回总共匹配到次数

str_info = "welcome to klion,klion is a pentester! "
print(str_info.count(‘klion‘,0,100))

isdecimal() 检查目标字符串是否为十进制字符[其实就是指整数],是则返回True,反之,则返回False,实际中用的较多
str_info = "3"
print(str_info.isdecimal())

isnumeric() 检查目标字符串是否为纯数字,用法同上,是则返回True,否则返回False
isalnum()   检查目标字符串是否为纯数字或字母组成,是则返回True,否则返回False

isspace()   检查目标字符串是否为空格,是则返回True,否则返回False
str_info = " "
print(str_info.isspace())

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

isprintable    检查目标字符串中是否存在不可见字符,如tab,空格...,是则返回True,否则返回False
str_info = "hello klion ^_^!"
print(str_info.isprintable())

用于接收的变量[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))

title    把目标字符串转换成标题样式,返回一个新的字符串
istitle  判断目标字符串是否为标题格式 [标题的每个单词首字母一般都会大写],是则返回True,否则返回False
str_info = "hello klion ^_^!"
t_res= str_info.title()
print(t_res.istitle())

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

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

center(要填充到的长度,"要填充的内容") 
填充居中,返回一个新字符串
str_info = "hello klion ^_^!"
res = str_info.center(30,"#")
print(res)

capitalize() 让整条语句首字母大写
str_info = "hello klion ^_^! hello kitty"
print(str_info.capitalize())

endswith()    判断目标字符串是否以指定字符结尾
str_info = "Hello klIon ^_^! hEllo KittY"
print(str_info.endswith(‘Y‘,21))

startswith() 判断目标字符串是否以指定字符开头
str_info = "Hello klIon ^_^! hEllo KittY"    
print(str_info.startswith(‘H‘,0))

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))

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

为真的情况就不说了,只说为假的情况,如下:
None
"" 空字符串
() 空元祖
[] 空列表
{} 空字典

列表类型,关键字list,以‘[]‘表示,以英文逗号对列表中的每个元素进行分割,列表中的元素可以是任意数据类型,并支持随意的增删改查及in操作,列表是有序的
li = list() 创建空列表
list_info = [‘klion‘,‘25‘,‘sec@sec. org‘,‘hello ‘,‘5324213‘,‘num‘,‘pentester‘,‘kali‘]
list_tmp = [‘num‘,23]

依然是通过 索引,切片取值,跟字符串用法基本是一样的,切完以后会返回一个新列表
print(list_info[3:-1])

for循环取出列表中的所有元素
print(len(list_info))    # len() 方法用来统计列表元素个数
for iterm in list_info:
　　print(iterm)

index(‘目标列表中的某个元素值‘,起始索引位置,结束索引位置)    返回某个元素在目标列表中的索引数值
print(list_info.index(‘pentester‘))

insert(指定要插入到的索引位置,‘要插入的内容‘)    往原有列表中插入新数据,会直接改变原有列表
res = list_info.insert(5,‘security‘)
print(list_info)
print(res)

append(要追加的元素) 往现有的列表里面里面追加一个新的列表项,把参数的整体作为一个列表元素
res = list_info.append(list_tmp)
print(list_info)
print(res)

extend(另一个列表) 通常用于将两个列表合并成一个列表,例如:字符串,列表,元祖,字典
res = list_info.extend(list_tmp)
print(list_info)
print(res)

pop(指定要删除的元素索引值)    删除指定的元素,会返回被删除的这个元素的值
res = list_info.pop(3)
print(list_info)
print(res)

remove(直接指定列表中的某个元素) 移除指定的元素,同样会直接改变原有列表
res = list_info.remove(‘kali‘)
print(list_info)
print(res)

reverse() 反转列表元素,会直接改变原有列表
res = list_info.reverse()
print(list_info)
print(res)

sort() 对列表中元素进行排序,默认升序
res = list_info.sort()
print(list_info)
print(res)

clear() 清空列表,单单只是清空列表项,并非删除该列表
res = list_info.clear()
print(list_info)
print(res)

copy() 把列表拷贝一份,属于浅拷贝
new_list = list_info.copy()
print(new_list)

count() 统计某个元素在列表中出现的次数
res = list_info.count(‘num‘)
print(list_info)
print(res)

把列表批量替换成字符串,如果列表中只有字符串,可以‘‘.join(list) 自动循环拼接,如下,
list_info = [‘sec‘,‘ok‘,‘connect‘]
str_res = ‘-‘.join(list_info)
print(str_res)

列表中既有字符串又有字符串则需要自己写循环,循环强制str转换成字符串再进行拼接
str_tmp = ‘‘
list_info = [‘sec‘,34,‘ok‘,‘connect‘,‘login‘,‘succeed‘,110]
for iterm in list_info:
str_tmp += str(iterm)
print(str_tmp)

多层嵌套取值
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 操作
if ‘klion‘ in list_info:
　　print(‘yeah is inter! ‘)
else:
　　print(‘Oh No!‘)

if ‘xlion‘ not in list_info:
　　print(‘yeah is outer! ‘)
else:
　　print(‘Oh No!‘)

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

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

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])

for iterm in range(len(tuple_res)):
print(iterm,‘=>‘,tuple_res[iterm])

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

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‘]
}
字典是根据键取值的
print(dict_info[‘email‘])
print(dict_info)

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

pop() 删除字典中指定的值
dels = dict_info.pop(‘phone‘)
print(dels)
print(dict_info)

keys() 把目标字典中的所有键取出来放到一个新的字典中
keys = dict_info.keys()
print(keys)

values()    把目标字典中的所有值取出来放到一个新的字典中
values = dict_info.values()
print(values)

items()    把目标字典中的所有键值取出来放到一个新的字典中
items = dict_info.items()
print(items)

clear()    清空目标字典,单单只是清空并不是删除
nulls = dict_info.clear()
print(nulls)

update()    更新某个键的值
new_age = dict_info.update({‘name‘:‘sec‘,‘age‘:‘45‘})
print(new_age)
print(dict_info)

fromkeys() 根据指定的key生成一个统一值的字典
allkey = dict_info.fromkeys([‘name‘,‘linces‘,‘tmp_num‘],18)
print(allkey)

定义一个集合
s = {1,2,3,4,5,‘klion‘,‘sec@sec.org‘,‘sec‘,‘klion‘,‘kali‘,4,‘wow‘}
p = {3,5,‘sec‘,‘nuddle‘,‘backbox‘,‘fedora‘}

add() 向集合中添加元素
s.add(‘linux‘)
print(s)

copy() 将集合复制一份
new_set = s.copy()
print(new_set)

pop() 随机删除集合中的一个元素
s.pop()
print(s)

clear() 清空集合中所有的元素,并非删除集合本身
s.clear()
print(s)

remove() 删除集合中指定的某个元素,如果没有该元素,会报错
s.remove(‘klion‘)
print(s)

discard() 删除集合中指定的元素,如果没有该元素,不会报错,常用
s.discard(‘xlion‘)
print(s)

s_n = set(s)
p_n = set(p)
print(s_n)
print(p_n)

交集 intersection() 或者 & 取出两个集合中的共同部分
print(‘交集‘,s_n&p_n)

并集 union()    或者 |    把两个集合中的所有元素去重合并
print(‘并集‘,s_n|p_n)

差集 difference()    或者 -    取出s_n中p_n没有的元素
print(‘差集‘,s_n-p_n)

补集 symmetric_difference() 或者 ^ 把两个集合合并然后抠除共有元素,留下剩余部分
print(‘补集‘,s_n^p_n)

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

+(加) -(减) *(乘以) /(除) //(直接取整,并非四舍五入) %(取余) **(x**y 表示x的y次方)

如果想在2.7中如果想让9/2输出结果为4.5 ,就必须先引入下面的模块
from __future__ import division 

python 2.7 
9/2 = 4

python 3.x
9/2 = 4.5

= += -= *= /= %= **= //=

==(等于) !=(不等于) <>(不等于,相当于!=) >(大于) <(小于) >=(大于或者等于) <=(小于或等于)

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

短路原则
and 前面一个条件为假,后面就不再计算了
or 前面条件如果为假,后面继续计算

in 
not in
字符 in 字符串 判断某个字符或字符序列是否在某个字符串中
字符 not in 字符串 判断某个字符或字符序列是否不在某个字符串中

值1[成立] if 条件 else 值2[不成立]
True if id > 1 else False

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

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

多分之:
if 条件一:
　　条件成立,执行此语句
elif 条件二:
　　条件成立,执行此语句
elif 条件三:
　　条件成立,执行此语句
else:
　　条件不成立,执行此语句[ pass表示什么都不做 ]

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

while 条件: 
　　....
else: 当上面的条件都不成立时则执行此代码块中语句,只会执行一次
　　....

break 跳出当前整个循环,且后面的代码不再执行

continue 只跳出当前这一次的循环,继续下一次循环

for 变量 in 条件:
　　要循环的语句
else:
　　上面的循环被正常执行完,也就是中间没有任何break或者continue,才会执行else里面的东西

range(起始值,总数,每次迭代的步长)
可专门用来获取指定范围内的数,默认是0开始的
for iterm in range(0,10,2):
　　print(iterm)

enumrate(可迭代的对象,起始位置[默认从0开始]) 会把这个可迭代对象的索引及索引对应的值一一遍历出来,如下,前面是索引,后面是索引对应的值
li = [‘redhat‘,‘debian‘,‘feodra‘,‘parrot‘,‘backbox‘,‘kali‘,‘alex‘,‘sec‘]
for iterm,fix in enumerate(li):
　　print(iterm,fix)

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

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)

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

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)