python中注释
单行注释：
#print('hello world')
#print('i am python')
多行注释：
'''
print('hello')
print('world')
'''
python2中使用中文
添加#coding=utf-8 或者 #-*- coding:utf-8 -*-代码
python中运算符
---------------------------------------------------------------------------------
| + 加 --- 两个对象相加 a + b 输出结果 31 |
| |
| - 减 --- 得到负数或是一个数减去另一个数 a - b 输出结果 -11 |
| |
| * 乘 --- 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210 |
| |
| / 除 --- x 除以 y b / a 输出结果 2.1 |
| |
| % 取模 --- 返回除法的余数 b % a 输出结果 1 |
| |
| ** 幂 --- 返回x的y次幂 a**b 为10的21次方 |
| |
| // 取整除 --- 向下取接近除数的整数 |
| 演示： |
| >>> 9//2 ->4 |
| >>> -9//2 ->-5 |
---------------------------------------------------------------------------------
python中print
python中print转义字符和格式化符号与C语言中的printf类似。
print转义字符表
---------------------------------------------------------------------------------
| \ (在行尾时) 续行符 |
| \\ 反斜杠符号 |
| \' 单引号 |
| \" 双引号 |
| \a 响铃 |
| \b 退格(Backspace) |
| \e 转义 |
| \000 空 |
| \n 换行 |
| \v 纵向制表符 |
| \t 横向制表符 |
| \r 回车 |
| \f 换页 |
| \oyy 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other 其它的字符以普通格式输出 |
---------------------------------------------------------------------------------
print格式化符号表
---------------------------------------------------------------------------------
| %c 格式化字符及其ASCII码 |
| %s 格式化字符串 |
| %d 格式化整数 |
| %u 格式化无符号整型 |
| %o 格式化无符号八进制数 |
| %x 格式化无符号十六进制数 |
| %X 格式化无符号十六进制数（大写） |
| %f 格式化浮点数字，可指定小数点后的精度 |
| %e 用科学计数法格式化浮点数 |
| %E 作用同%e，用科学计数法格式化浮点数 |
| %g %f和%e的简写 |
| %G %f 和 %E 的简写 |
| %p 用十六进制数格式化变量的地址 |
---------------------------------------------------------------------------------
print输出多个变量
a,b,c=10,'hello world','3.14'
print('a=%d,b=%s,c=%f'%(a,b,c))#格式化符号和C语言一样
python中input
python2和python3中input是不同的，py2中将你输入的内容当作一段代码执行了，py3中你输入的内容全为字符串。
py2中：
result = input('请输入一个数字')
输入：2 + 3
输出：5
py3中：
result = input('请输入一个数字')
输入：2 + 3
输出：'2 + 3'
如果要在py2中达到py3中的input功能，使用raw_input()
python中类型转换
---------------------------------------------------------------------------------
| int(x [,base ]) 将x转换为一个整数 |
| long(x [,base ]) 将x转换为一个长整数 |
| float(x ) 将x转换到一个浮点数 |
| complex(real [,imag ]) 创建一个复数 |
| str(x ) 将对象 x 转换为字符串 |
| repr(x ) 将对象 x 转换为表达式字符串 |
| eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s ) 将序列 s 转换为一个元组 |
| list(s ) 将序列 s 转换为一个列表 |
| chr(x ) 将一个整数转换为一个字符 |
| unichr(x ) 将一个整数转换为Unicode字符 |
| ord(x ) 将一个字符转换为它的整数值 |
| hex(x ) 将一个整数转换为一个十六进制字符串 |
| oct(x ) 将一个整数转换为一个八进制字符串 |
--------------------------------------------------------------------------------|
演示：
a = 100
#将整型a转换为字符串'100'
print(type(str(a))) #-><class 'str'>
#将字符串b转换为整型b
b = '100'
print(type(str(b))) #-><class 'int'>
python中全局变量与局部变量
演示1：
#定义全局变量var1
var1 = 100
def test1(num):
#此处进行修改全局变量var1
var1 = num + 100
print(var1) #->200
test1(var1)
#可以看到var1在test1中修改无效
print(var1) #->100
演示2：
如果要修改演示1中的var1变量，请看下面
var1 = 100
def test1(num):
#此处需要添加global关键字
global var1
#此处进行修改全局变量var1
var1 = num + 100
print(var1) #->200
test1(var1)
#可以看到var1在test1中修改有效
print(var1) #->200
演示3：
_list = [10,20,30,40]
_dict = {}
def test1():
_list.append(100)
_dict['name'] = 'jack'
test1()
print(_list) #->[10,20,30,40,100]
print(_dict) #->{'name':'jack'}
总结：列表、字典全局变量在函数中调用无需申明global关键字，
其他全局变量必须声明global关键字，才可修改。
python中变量的引用
演示1：
one = 100
two = one
#id可以获取变量内存地址
print(id(one),id(two)) #->10922592,10922592
#从上面可以看到two是指向one地址空间的
python中pass语句
Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
Python 语言 pass 语句语法格式如下：
def test():
pass
python中循环
1.for循环
for循环中可以跟else使用
for num in range(0,100):
print(num)
else:
print('complete')
执行完了100次之后才会执行print('complete')
2.while循环
count = 0
while count != 10:
print(count)
count+=1
3.循环控制
break，continue
python中字符串
字符串运算符
-----------------------------------------------------------------------------------------
| + 字符串连接 >>>a + b 'HelloPython' |
| |
| * 重复输出字符串 >>>a * 2 'HelloHello' |
| |
| [] 通过索引获取字符串中字符 >>>a[1] 'e' |
| |
| [:] 截取字符串中的一部分 >>>a[1:4] 'ell' |
| |
| in 成员运算符 - 如果字符串中包含给定的字符返回 True >>>"H" in a True |
| |
| not in 成员运算符 - 如果字符串中不包含给定的字符返回 True >>>"M" not in a True |
| |
| r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特 |
| 殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以 |
| 外，与普通字符串有着几乎完全相同的语法。 >>>print r'\n'\n >>> print R'\n'\n |
| |
| % 格式字符串 |
-----------------------------------------------------------------------------------------
str.capitalize()
函数功能：将字符串首个字母大写：
函数参数：无
返回值：无
演示：
string = 'hello world'
print(string.capitalize()) ->'Hello world'
str.isalnum()
函数功能：判断字符串内容是否为字母或者数字
函数参数：无
返回值：如果是返回True，反之False
演示：
string = 'hello100'
print(string.isalnum()) ->True
str.join(元组、列表、字典、字符串)
函数功能：将序列中的元素以指定的字符连接生成一个新的字符串
函数参数：无
返回值：连接生成的新字符串
演示：
_list = ['a','b','c','d']
string = '='
result = string.join(_list)
print(result) ->'a=b=c=d'
str.rsplit([sep=None][,count=str.count(sep)])
函数功能：通过指定分隔符对字符串进行分割并返回一个列表，
默认分隔符为所有空字符，包括空格、换行(\n)、制表符(\t)等。
类似于split()方法，只不过是从字符串最后面开始分割。
函数参数：无
返回值：返回分割后的字符串列表。
演示：
string = "this is string example....wow!!!"
print (string.rsplit( )) ->['this', 'is', 'string', 'example....wow!!!']
print (string.rsplit('i',1))->['this is str', 'ng example....wow!!!']
print (string.rsplit('w')) ->['this is string example....', 'o', '!!!']
str.casefold()
函数功能：casefold()方法删除字符串中存在的所有大小写区别。
它用于无壳匹配，即在比较时忽略大小写。
例如，德语小写字母?相当于ss。但是，由于?已经是小写的，
因此lower（）方法对它没有任何作用。但是，casefold（）将其转换为ss
函数参数：无
返回值：转换为小写后的字母
演示：
firstString = "der Flu?"
secondString = "der Fluss"
# ? is equivalent to ss
if firstString.casefold() == secondString.casefold():
print('The strings are equal.')
else:
print('The strings are not equal.')
输出：'The strings are equal.'
str.isalpha()
函数功能：如果字符串中的所有字符都是字母，则isalpha（）方法返回True。如果不是，则返回False。
函数参数：无
返回值：如果字符串中的所有字符都是字母（可以是小写和大写），则为True。
如果至少一个字符不是字母，则返回false。
str.ljust(width [，fillchar])#这里，fillchar是一个可选参数。
函数功能：返回给定最小宽度的左对齐字符串。
函数参数：
width - 给定字符串的宽度。如果width小于或等于字符串的长度，则返回原始字符串。
fillchar（可选） - 填充宽度剩余空间的字符
返回值：
ljust()方法返回给定最小宽度内的左对齐字符串。
如果定义了fillchar，它还会使用定义的字符填充剩余空间。
演示：
string = 'jack'
print(string.ljust(10,'-')) ->'jack------'
print(string.ljust(10)) ->'jack '
str.rstrip([chars])
函数功能：从str右侧删除chars中所包含的字符串
函数参数：要删除的字符串
返回值：所删除字符串的结果
演示：
string = 'hello world hello world'
print(string.rstrip('ld')) ->'hello world hello wor'
print(string.rstrip('dl')) ->'hello world hello wor'
str.center(width[,fillchar])#fillchar可选参数
函数功能：将字符串居中
函数参数：
width - 给定字符串的宽度。如果width小于或等于字符串的长度，则返回原始字符串。
fillchar（可选） - 填充宽度剩余空间的字符
返回值：
center()方法返回给定最小宽度内的左对齐字符串。
如果定义了fillchar，它还会使用定义的字符填充剩余空间。
演示：
string = 'hello world'
print(string.center(10)) ->'hello world'
print(string.center(50)) ->' hello world '
print(string.center(50,'*'))->'*************hello world**************'
str.isdecimal()
函数功能：判断字符串中的所有字符是否都是十进制字符
函数参数：无
返回值：都是十进制字符True，反之False
演示：
string = '1000'
print(string.isdecimal()) ->True
string = '3.14'
print(string.isdecimal()) ->False
string = 'hello20000'
print(string.isdecimal()) ->False
str.lower()
函数功能：将所有字符串转换为小写
函数参数：无
返回值：转换完成之后的小写字符
演示：
string = 'HELLO WORLD'
print(str.lower()) ->'hello world'
str.split([separator [，maxsplit]])
函数功能：指定的分隔符处分解字符串并返回字符串列表
函数参数：
separator（可选） - 是分隔符。字符串在指定的分隔符处分割。
如果未指定分隔符，则任何空格（空格，换行符等）字符串都是分隔符。
maxsplit（可选） - maxsplit定义最大拆分数。maxsplit
的默认值为-1，表示分割数量没有限制。
返回值：字符串列表
演示：
text= 'Love thy neighbor'
# splits at space
print(text.split()) ->['Love', 'thy', 'neighbor']
grocery = 'Milk, Chicken, Bread'
# splits at ','
print(grocery.split(', ')) ->['Milk', 'Chicken', 'Bread']
# Splitting at ':'
print(grocery.split(':')) ->['Milk, Chicken, Bread']
grocery = 'Milk, Chicken, Bread, Butter'
# maxsplit: 2
print(grocery.split(', ', 2)) ->['Milk', 'Chicken', 'Bread, Butter']
# maxsplit: 1
print(grocery.split(', ', 1)) ->['Milk', 'Chicken, Bread, Butter']
# maxsplit: 5
print(grocery.split(', ', 5)) ->['Milk', 'Chicken', 'Bread', 'Butter']
# maxsplit: 0
print(grocery.split(', ', 0)) ->['Milk, Chicken, Bread, Butter']
str.count(substring, start=..., end=...)
函数功能：统计substring在str中出现的次数
函数参数：
substring - 要查找其计数的字符串。
start（可选） - 在搜索开始的字符串中开始索引。
end（可选） - 搜索结束的字符串中的结束索引。
返回值：substring出现的次数
演示：
string = "Python is awesome, isn't it?"
substring = "is"
count = string.count(substring)
# print count
print("The count is:", count) ->The count is: 2
substring = "i"
# count after first 'i' and before the last 'i'
count = string.count(substring, 8, 25)
# print count
print("The count is:", count) ->The count is: 1
str.isdigit()
函数功能：判断字符串中是否所有字符都是数字
函数参数：无
返回值：是True，不是False
演示：
s = "28212"
print(s.isdigit()) #->True
# contains alphabets and spaces
s = "Mo3 nicaG el l22er"
print(s.isdigit()) #->False
s = '23455'
print(s.isdigit()) #->True
#s = '²3455'
# subscript is a digit
s = '\u00B23455'
print(s.isdigit()) #->True
# s = '½'
# fraction is not a digit
s = '\u00BD'
print(s.isdigit()) #->False
str.lstrip([chars])#chars可选
函数功能：从字符串左边开始删除chars或者空格
函数参数：
chars（可选） - 一个字符串，指定要删除的字符集。
如果未提供chars参数，则从字符串中删除所有前导空格
返回值：返回带有前导字符的字符串副本
演示：
string = ' hello world,hello python,python is very powerful'
print(string.lstrip()) #->'hello world,hello python,python is very powerful'
print(string.lstrip('hello')) #->' world,hello python,python is very powerful'
print(string.lstrip('python')) #->' hello world,hello ,python is very powerful'
str.format_map(字典)
执行字符串格式化操作，替换字段使用{}分隔
演示：
name,country = 'jack','china'
print('{x} is in {y}'.format_map({'x':name,'y':country}))
输出：'jack is in china'
python中列表
列表添加元素：list.append(要添加的元素)
列表复制元素（浅拷贝）：list.copy()
注意：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
演示：
list1 = [10,20,30,[40,50,60]]
list2 = []
list2 = list1.copy()
print(list2)
输出：list2->[10,20,30,[40,50,60]]
list1[3].append(70)
list1[0] = 100
print(list2) #->[10,20,30,[40,50,60,70]]
列表合并元素：list.extend(另外一个列表)
演示：
list1 = ['a','b','c']
list2 = ['f','g','h']
list1.extend(list2)
print(list1)
输出：['a','b','c','f','g','h']
列表插入元素：list.insert(位置,插入内容)
列表删除元素：list.remove(指定内容) 或者 del list[x]（x代表下标）
列表排序元素：list.sort()#升序 list.sort(reverse=True)#降序
列表清空元素：list.clear()
列表统计元素出现的个数：list.count(要统计的元素)
列表获取元素的下标：list.index(要获取下标的元素)
列表尾部删除元素：list.pop()
列表反转元素：list.reverse()
python中字典：
字典添加元素：
_dict = {}
_dict['name'] = 'jack'
_dict['age'] = 22
_dict['gender'] = 'male'
print(_dict) #->{'name':'jack','age':22,'gender':'male'}
dict.clear()
函数功能：字典清空元素
函数参数：无
返回值：空字典
dict.clear()
print(_dict) #->{}
dict.fromkeys(seq[, value])
函数功能：用于创建一个新字典，以序列seq中元素做字典的键，
value为字典所有键对应的初始值。
函数参数：
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值
返回值：新字典
演示：
_list = ['name','age','gender']
_dict = dict.fromkeys(_list)
print(_dict) #->{'name':None,'age':None,'gender':None}
_dict = dict.fromkeys(_list,100)
print(_dict) #->{'name':100,'age':100,'gender':100}
dict.items()
函数功能：以列表返回可遍历的(键, 值) 元组数组
函数参数：无
返回值：返回可遍历的(键, 值) 元组数组。
演示：
_dict = {'name':'jack','gender':'male','age':20}
print(_dicct.items()) #->dict_items([('gender', 'male'), ('age', 20), ('name', 'jack')])
dict.pop(key[,default])
函数功能：删除字典给定键 key 及对应的值key值必须给出。否则，报错。
函数参数：要删除的键值
返回值：被删除的值
演示：
_dict = {'name':'jack','gender':'male','age':20}
print(_dict.pop('name')) #->'jack'
#此处pop没有给参数，则报错
print(_dict.pop())
#TypeError Traceback (most recent call last)
#<ipython-input-3-609a8a44c062> in <module>()
#----> 1 _dict.pop()
dict.setdefault(key, default=None)
函数功能：和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
函数参数：
key -- 查找的键值。
default -- 键不存在时，设置的默认键值。
返回值：如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。
演示：
_dict = {'name':'jack','gender':'male','age':20}
print(_dict.setdefault('name')) #->'jack'
print(_dict.setdefault('favorite','running')) #->'running'
print(_dict) #->{'name':'jack','gender':'male','age':20,'favorite':'running'}
dict.values()
函数功能：以列表返回字典中的所有值。
函数参数：无
返回值：字典中所有值
演示：
_dict = {'name':'jack','gender':'male','age':20}
print(_dict.values()) #->['jack','male',20]
dict.copy()
函数功能：返回一个字典的浅拷贝。
函数参数：无
返回值：字典的浅拷贝。
注意：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
演示：
d1 = {'age':20,'score':[100,90,99,88]}
d2 = d1.copy()
print(d2) #-> {'age':20,'score':[100,90,99,88]}
d1['age'] = 22
d1['socre'].remove(1)
print(d1) #->{'age':22,'score':[100,99,88]}
print(d2) #->{'age':20,'score':[100,99,88]}
dict.get(key, default=None)
函数功能：返回指定键的值，如果值不在字典中返回默认值。
函数参数：
key -- 字典中要查找的键。
default -- 如果指定键的值不存在时，返回该默认值值。
返回值：返回指定键的值，如果值不在字典中返回默认值None。
d1 = {'name':'jack','age':20}
print(d1.get('name')) #-> 'jack'
print(d1.get('favorite')) #-> 'None'
print(d1.get('favorite','get')) #-> 'get'
dict.keys()
函数功能：以列表返回一个字典所有的键。
函数参数：无
返回值：返回一个字典所有的键。
d1 = {'name':'jack','age':20}
print(d1.keys()) #->['name','age']
dict.popitme()
函数功能：随机返回并删除字典中的一对键和值。
如果字典已经为空，却调用了此方法，就报出KeyError异常。
函数参数：无
返回值：返回一个键值对(key,value)形式
d1 = {'name':'jack','gender':'male','age':20}
print(d1.popitem()) #->('name','jack')
print(d1) #->{'gender':'male','age':20}
print(d1.popitem()) #->('gender','male')
print(d1) #->{'age':20}
dict.update(dict2)
函数功能：将dict2中的键值更新到dict中
函数参数：dict2要更新到dict中的字典
返回值：无
d1 = {'name':'jack','age':20}
d2 = {'gender':'male','favorite':'running'}
d1.update(d2)
print(d1) #->{'name':'jack','age':20,'gender':'male','favorite':'running'}
python中元组：
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
#元组只有一个元素时的表示方法
_tuple = (10,)
_tuple = (10,20,20,30,30,30,50,50,50,50)
元组统计元素出现的个数：
tuple.count(元素)
演示：
print(_tuple.count(30),_tuple.count(50)) #->3,4
删除元组：
演示：
del _tuple
检索元组元素第一次出现的索引：
tuple.index(str, beg=0, end=len(string))
演示：
_tuple = ('jack','age','jack','tom','jack',our','our','age')
print(_tuple.index('jack')) #-> 0
print(_tuple.index('jack',1)) #-> 2
print(_tuple.index('jack',3,5)) #-> 4
python中函数：
定义一个函数的方法：
#无参函数
def func():
pass
#有参函数
def func(a,b):
pass
#可变参数函数:
def func(*args,**kwargs):
#此处*args是一个list,
#**kwrags是一个dict
pass
函数的返回值：
一个返回值：
def func():
a = 10
return a
多个返回值：
def func():
a,b,c = 10,20,30
return a,b,c
函数缺省参数：
def func(a,b=10):
return a+b
print(func(10)) #->20
print(func(10,20)) #->30
def func(a,b=10,c=20):
return a+b+c
#此处c=100中的c一定要与func中定义的形参名c一样
print(func(10,c=100)) #->120
匿名函数
演示：
_list = [{'name':'jack','age':22,'gender':'male'},
{'name':'tom','age':21,'gender':'male'},
{'name':'helen','age':23,'gender':'female'}]
_list.sort(key=lambda x:x['name'])
print(_list) ->[{'name':'tom','age':21,'gender':'male'},
{'name':'jack','age':22,'gender':'male'},
{'name':'helen','age':23,'gender':'female'}]
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
