数据
变量指向
a="hello python"
b=a
a=123
#a与b指向同一内存空间
字符串
name="alex \tname is alex"
name.capitalize() # 首字母大写
name.count("a") # 统计字母个数
name.center(50,"-") #总共打印50个字符，并把nam放在中间，不够的用-补上
name.endswith("ex") # 判断字符串以什么结尾
name.expandtabs(tabsize=30) # 将name中\t转为30个空格
name.find("x") # 取索引
'ab123'.isalnum() #是否包含字母及数字以外的字符，是返回false
'ab123'.isalpha() # 包含纯英文字符
'1A'.isdecimal() # 是否是十进制
'1A'.isdigit() # 是否是整数
'_'.isidentifier() #判断是否是合法的标识符，
'aasd'.islower() # 判断是否是小写
''.isspace() # 是否是空格
'My name is'.istitle() # 字符串的字母是否大写
'+'.join(['1','2','3']) #1+2+3
name.ljust(50,'*') # 左对齐字符串，多余位用*补全
name.rjust(50,'-') # 右对齐字符串，多余位用*-补全
'\n Alex'.lstrip() # 去掉左边的空格/回车
'\nAlex\n'.rstrip() # 去掉右边的空格/回车
'\nAlex\n'.strip() # 去掉左边和右边的空格/回车
"alex li".rfind('l') # 找到的最右边的下标返回
"alex li".split('l') #['a', 'ex ', 'i']
"1+2+3+4".split('+') # ['1', '2', '3', '4']
"1+2\n+3+4".splitlines() # ['1+2', '+3+4']
"Alex Li".swapcase() # aLEX lI
'lex li'.title() # Lex Li
'lex li'.zfill(50) #50个字符，不够以0填充
#填补
name="my \tname is {name} and i am {year} old"
name.format(name="alex",year=23)
name.format_map({'name':'alex','year':23})
#替换
p=str.maketrans("abcdef","123456")
print("alex li".translate(p)) #把alex li换成上一行对应的值 1l5x li
"alex li".replace('l','L',1) # 替换 1表示替换几个l,从左到右计算替换个数 aLex li
列表
创建
name = ['一点水', '两点水', '三点水', '四点水', '五点水']
print(name[2])# 通过索引来访问列表
print(name[0:2])# 通过方括号的形式来截取列表中的数据
注意：编程中，都是从 0 开始的，而不是从 1 开始。[0:2]是**左闭右开**区间
name[1]='2点水' # 通过索引对列表的数据项进行修改或更新
name.append('六点水') # 使用 append() 方法来添加列表项
del name[3] # 使用 del 语句来删除列表的的元素
运算
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| 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 | 迭代 |
方法
| 函数&方法 | 描述 |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元组转换为列表 |
| list.append(obj) | 在列表末尾添加新的对象 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| list.insert(index, obj) | 将对象插入列表 |
| list.pop(obj=list[-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| list.remove(obj) | 移除列表中的一个元素（参数是列表中元素），并且不返回任何值 |
| list.reverse() | 反向列表中元素 |
| list.sort([func]) | 对原列表进行排序 |
| replace(“快乐”, “happy”) | 数据替换 |
| names.copy() | 浅拷贝 |
元组
创建
tuple1=('两点水','twowter','liangdianshui',123,456)
tuple2='两点水','twowter','liangdianshui',123,456
tuple3=() #创建空元组
tuple4=(123,) #创建只包含一个元素的元组。()既可以表示元组（tuple），又可以表示数学公式中的小括号。
tuple4=(123) #创建一个整数
print(tuple2[0]) #使用下标索引来访问元组中的值
del tuple1 #使用 del 语句来删除整个元组
运算
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| 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 | 迭代 |
| 方法 |
| 方法 | 描述 |
|---|---|
| len(tuple) | 计算元组元素个数 |
| max(tuple) | 返回元组中元素最大值 |
| min(tuple) | 返回元组中元素最小值 |
| tuple(seq) | 将列表转换为元组 |
| count(“tuple”) | 统计个数 |
| index(“tuple”) | 返回位置 |
字典
#创建
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
dict2={'abc':1234,1234:'abc'} #创建
dict() # 创建空字典 {}
dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 {'three': 3, 'two': 2, 'one': 1}
dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 {'three': 3, 'two': 2, 'one': 1}
dict['abc'] #通过键值访问
#修改
dict1['jack']='444444' # 新增一个键和值
dict1['liangdianshui']='555555' # 修改键对应的值
#删除
del dict1['twowater'] # 通过 key 值，删除对应的键和值
dict1.clear() # 删除字典中的所有元素
del dict1 # 删除字典
k.pop('like') #删除键和值
#键值
k.keys()
k.values()
info.items() #把一个字典转成列表
info.fromkeys([6,7,8],"test"#{6: 'test', 7: 'test', 8: 'test'}
方法
| 方法和函数 | 描述 |
|---|---|
| len(dict) | 计算字典元素个数 |
| str(dict) | 输出字典可打印的字符串表示 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型 |
| dict.clear() | 删除字典内所有元素 |
| dict.copy() | 返回一个字典的浅复制 |
| dict.values() | 以列表返回字典中的所有值 |
| popitem() | 随机返回并删除字典中的一对键和值 |
| dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
集合
set1=set([123,456,789])
set1.add(100) #集合set1添加100
set1.remove(456) #删除元素46
set1.update([10,37,42]) # 添加多项
set1.discard('x')# 删除一个指定的值
set4=set1 | set2 # 并集 （合并两个 set 集合的元素并去除重复的值）
set3=set1 & set2 # 交集 (求两个 set 集合中相同的元素)
set5=set1 - set2 # 差集 把list_1与list_2互相都没有的元素放在一块，其实就是去掉重复元素
new = set(a)#去除重复元素
控制语句
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
for iterating_var in sequence: #迭代输出
statements(s)
while 判断条件: #迭代输出
执行语句__
result = 值1 if 条件 else 值2 #三元运算，满足if返回值1，否则值2
列表生成 三种形式
[<表达式> for (条件变量) in (集合)][<表达式> for (条件变量) in (集合) if <'True or False'表达式>][<表达式> if <'True or False'表达式> else <表达式> for (条件变量) in (集合) ]
fruits = ['"Apple', 'Watermelon', '"Banana"']
[x.strip('"') for x in fruits] #甩出x,占一个位置
[x for x in range(21) if x%2] #x满足if,甩出x,然后站一个位置
[m + n for m in 'ABC' for n in 'XYZ'] # m的for循环，嵌套n的for循环，甩出的nm站一个位置
d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]
| 循环控制语句 | 描述 |
|---|---|
| break | 在语句块执行过程中终止循环，并且跳出整个循环 |
| continue | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环 |
| pass | pass 是空语句，是为了保持程序结构的完整性 |
函数
def 函数名(参数1，参数2....参数n):
函数体
return 语句
#高阶函数
#把另一个函数作为参数传入一个函数，这样的函数称为高阶函数
常用函数
input("输入")
print("输出")
info="Name":+name
info="Job:%s"%(job)
info="Job:{_job}".format(_job=job)
info="Job:{2}".format(job)
getpass.getpass("请输入密码:") #import getpass
#sys
#打印环境变量
sys.path
sys.argv
#进度条
import time
for i in range(50):
sys.stdout.write('#')
sys.stdout.flush()
time.sleep(0.5)
#os
os.mkdir("new_dir3") # 创建一个目录
os.removedirs("new_dir3") # 删除一个目录
os.popen("dir").read() #目录
#文件
f=open('test','a',encoding='utf-8') # 文件句柄 'a'为追加文件，'w'重写，'r'读
f.write("\n阿斯达")
f.close()
f.readline().strip() #读一行，strip()去掉空格和回车
f.readlines() #读所有行
for index, line in enumerate(f.readlines()): #enumerate添加行号
f.tell()#读取的指针当前位置
f.seek(0) #移动到读取的指针到开头
with open('ly.txt', 'r', encoding='utf-8') as f:# with语句---为了避免打开文件后忘记关闭，可以通过管理上下文
匿名函数
# -*- coding: UTF-8 -*-
num2 = 100
sum1 = lambda num1 : num1 + num2 ; #num1 传入参数，num1 + num2返回值
num2 = 10000
sum2 = lambda num1 : num1 + num2 ;
print( sum1( 1 ) )
print( sum2( 1 ) )
#结果
10001
10001
迭代
# -*- coding: UTF-8 -*-
# 1、for 循环迭代字符串
for char in 'liangdianshui' :
print ( char , end = ' ' )#l i a n g d i a n s h u i
# 2、for 循环迭代 list
list1 = [1,2,3,4,5]
for num1 in list1 :
print ( num1 , end = ' ' ) #1 2 3 4 5
# 3、for 循环也可以迭代 dict （字典）
dict1 = {'name':'两点水','age':'23','sex':'男'}
for key in dict1 : # 迭代 dict 中的 key
print ( key , end = ' ' ) #name age sex
for value in dict1.values() : # 迭代 dict 中的 value
print ( value , end = ' ' ) #两点水 23 男
# 如果 list 里面一个元素有两个变量，也是很容易迭代的
for x , y in [ (1,'a') , (2,'b') , (3,'c') ] :
print ( x , y )
#1 a
#2 b
#3 c
#zip
names = ['laingdianshui', 'twowater', '两点水']
ages = [18, 19, 20]
for name, age in zip(names, ages):
print(name,age)
#字典
names = ['laingdianshui', 'twowater', '两点水']
ages = [18, 19, 20]
dict1= dict(zip(names,ages))
print(dict1)
迭代器
# 1、字符创创建迭代器对象
str1 = 'liangdianshui'
iter1 = iter ( str1 )
# 2、list对象创建迭代器
list1 = [1,2,3,4]
iter2 = iter ( list1 )
# 3、tuple(元祖) 对象创建迭代器
tuple1 = ( 1,2,3,4 )
iter3 = iter ( tuple1 )
# for 循环遍历迭代器对象
for x in iter1 :
print ( x , end = ' ' ) #l i a n g d i a n s h u i
# next() 函数遍历迭代器
while True :
try :
print ( next ( iter3 ) ) # 1 2 3 4
except StopIteration :
break
生成器
# -*- coding: UTF-8 -*-
gen= (x * x for x in range(10))
for num in gen :
print(num)
类
class ClassA(): #创建
var='abc'
@classmethod 声明该方法是类方法。只有声明了是类方法，才能使用类属性
def fun():
cls.var=inpt('请输入值:')# 内部修改值。cls把这个类作为参数，传给自己，
ClassA.fun()
ClassA.var=input('请输入值：') #外部修改值
a= ClassA() #实例化
a.fun1() #类的访问
继承
class ClassName(Base1,Base2,Base3):
<statement-1>
.
.
.
<statement-N>
访问控制
class UserInfo(object):
def __init__(self, name, age, account):
self.name = name #公开属性，类内类外都可以访问
self._age = age #私有属性，类内能访问，类外不可以访问
self.__account = account #不算私有属性，该属性在创建的时候是不可以访问
def get_account(self):
return self.__account
方法
| 方法 | 说明 |
|---|---|
__init__ | 构造函数，在生成对象时调用 |
__del__ | 析构函数，释放对象时使用 |
__repr__ | 打印，转换 |
__setitem__ | 按照索引赋值 |
__getitem__ | 按照索引获取值 |
__len__ | 获得长度 |
__cmp__ | 比较运算 |
__call__ | 函数调用 |
__add__ | 加运算 |
__sub__ | 减运算 |
__mul__ | 乘运算 |
__div__ | 除运算 |
__mod__ | 求余运算 |
__pow__ | 乘方 |
线程
正则表达式
import re
# 设定一个常量
a = '两点水|twowater|liangdianshui|草根程序员|ReadingWithU'# 选择 a 里面的所有小写英文字母
re_findall = re.findall('[a-z]', a)#获取字符串a中的所有小写字母了。
a = 'uav,ubv,ucv,uwv,uzv,ucv,uov' # 字符集
findall = re.findall('u[abc]v', a)# 取 u 和 v 中间是 a 或 b 或 c 的字符
re.findall('u[a-c]v', a) # 如果是连续的字母，数字可以使用 - 来代替
re.findall('u[^abc]v', a)# 取 u 和 v 中间不是 a 或 b 或 c 的字符
a = 'uav_ubv_ucv_uwv_uzv_ucv_uov&123-456-789'# 概括字符集
# \d 相当于 [0-9] ,匹配所有数字字符
# \D 相当于 [^0-9] ， 匹配所有非数字字符
# \w 匹配包括下划线的任何单词字符，等价于 [A-Za-z0-9_]
findall1 = re.findall('\d', a)
findall3 = re.findall('\D', a)
findall5 = re.findall('\w', a)
a = 'Python*Android*Java-888'
sub1 = re.sub('\*', '&', a) # 把字符串中的 * 字符替换成 & 字符
sub2 = re.sub('\*', '&', a, 1)# 把字符串中的第一个 * 字符替换成 & 字符
sub3 = re.sub('[\*-]', convert, a)# 第二个参数，要替换的字符可以为一个函数
re.search(pattern, string, flags=0)#扫描整个字符串并返回第一个成功的匹配。
re.match(pattern, string, flags=0)#字符串的起始位置匹配一个模式