Python基础基础基基础

格式化输出

例1. 
"Hi,%s,you have %d"%("Michael",100000)

out:'Hi,Michael,you have 100000'

• %d 表示整数
• %f 表示浮点数
• %s表示字符串
• %2d 显示两位整数 如果是一位在前面加一个空格
• %02d 显示两位整数 如果是一位数前面补0
  例2.

例2. 
"%2d-%02d"%(3,1)
out：' 3-01'

• %.2f表示浮点数保留两位小数

例3. 
"%.2f" %3.14159
out:'3.14'

• 如果不确定，%s永远起作用，可以把任何数据类型转化成字符串

例4. 
"age:%s gender:%s" %(25,True)
out:'age:25 gender:True'

• 小明成绩从72到了85分，计算小明成绩提升的百分点，用字符串格式化显示“xx.x%”保留一位小数
• %%两个百分号只显示一个

例5.
"%.1f%%" % ((85-72)/72*100)
out：'18.1%'

循环段

例1. 打印图形：m行，每行打印n次，n==m

m=1
while m <=5:
    n=1
    while n <= m :
        print("*",end=" ")
        n = n+1
    print() #换行符
    m=m+1
* 
* * 
* * * 
* * * * 
* * * * * 

例2.

#while的九九乘法表
m=1
while m <= 9:
    n=1
    while n<= m:
        print("{}*{}={}".format(n,m,m*n),end=" ")
        n=n+1
    print()
    m=m+1

for m in range(1,10):
    for n in range(1,m+1):
        print("{}*{}={}".format(n,m,n*m),end=" ")
    print()

例3.

• break 提前结束循环
• continue 跳过当前的这次循环 直接开始下一次循环
• 但是大多数break/continue可以通过改写循环条件替代

n=1
while n <=100:
    if n > 10:
        break
    print(n,end=" ")
    n=n+1
out: 1 2 3 4 5 6 7 8 9 10

n=0
while n < 10:
    n=n+1
    if n % 2 ==0:
        continue
    print(n,end=" ")   
out: 1 3 5 7 9

字符串处理

• 切片
• find(“str”,start,end)
  找不到返回-1
• rfind()
• index(“str”,start,end)
  找不到报错
• rindex()
• count(“str”,start,end)
• replace(old,new,替换不超过的count数)
• split(“分隔符”) 返回元素为字符串的列表
• splitlines() 分隔符为换行符

lines="""line1
line2
line3"""
print(lines.splitlines())
out：['line1', 'line2', 'line3']

格式刷

• capitalize() 把第一个字符大写

• title() 把字符的每个单词首字母大写

• lower() 转换所有字符为小写

• upper() 转换所有字符为大写

• ljust(width,“补全符”)
  原字符串左对齐，并用补全符填充到长度为width

• rjust(width) 右对齐

• center(width) 居中

• lstrip() 删除左边的空格

• rstrip() 删除右边的空格

• strip() 删除两边的空格

• partition(“指定str”) 拆成str左,首次出现的str,str右 三个元素的列表

• rpartition() 右边开始首次出现的str

bool型

• startwith(“str”,start,end) 是否以特定str开头
• endwith() 是否以str结束
• isalpha() 所有字符是否都是字母
• isdigit() 所有字符是否都是数字
• isalnum() 所有字符是否都是字母或数字
• isspace() 所有字符是否都是空格

列表

创建列表

ls=[] 可以存放各种数据类型

lista=['mike',1234,True,3.14]

访问

• list[index]
• list[切片]

添加元素

• list.append()
• list.insert(index,obj)
  在指定index插入元素obj

修改元素

• list[index]=new

查找元素

• if obj in list:
• not in
• list.index(obj,start,end)

ls=['a','b','c','a','b']
ls.index('a',0,4)
out：0 获取第一个a的下标

• list.count(obj) 返回出现次数

删除元素

• del list[index]
• list.pop() 默认弹出最后一个元素
  list.pop(index)
• list.remove(obj)

list_shan=['abcdefg',['a','bb','ccc'],'dddd','ff']
del list_shan[0]
print(list_shan)
out:[['a', 'bb', 'ccc'], 'dddd', 'ff']
list_shan.pop()
print(list_shan)
out:[['a', 'bb', 'ccc'], 'dddd']
list_shan.remove('dddd')
print(list_shan)
out:[['a', 'bb', 'ccc']]

排序

• list.reverse() 倒序
• list.sort() 按大小排序
• list.sort(reverse=True) 倒序

迭代器 enumerate(list)

list_enu=['abcdefg',['a','bb','ccc'],'dddd','ff']
for i,j in enumerate(list_enu):
    print(i,j)
out:0 abcdefg
1 ['a', 'bb', 'ccc']
2 dddd
3 ff

常用方法

• list.append(obj)：在列表末尾添加新的对象
• list.count(obj)：统计某个元素在列表中出现的次数
• list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
• list.remove(obj)：移除列表中某个值的第一个匹配项

元组

与列表类似，可以存储各种数据类型，但是元素不能修改
ps：元组套列表时，列表是可变的

创建元组

• tuple=()

t=(1)
print(t)
out:1
t=(1,)#创建单元素列表要加逗号
print(t)
out:(1,)

访问元组

• tuple[index]

内置函数

• tuple.index(obj,start,end)
• tuple.count(obj) 返回出现次数

元组相加（连接）

t1=(1,2,3)
t2=(4,5,6)
print(t1+t2)
out：(1, 2, 3, 4, 5, 6)

字典

• 一个键对应一个值
• 每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号分割 键必须是唯一的，但值则不必。
• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

创建字典

• index:value 创建键值对

dict_info={'Mike': 95, 'Bob': 75, 'Tracy': 85}

访问字典

• dict[‘键名’]
• dict.get(‘键名’,default)

修改字典

• dict[‘键名’]=new

添加字典

如果用dict[‘键名’]=new，不存在这个键，就会新增这个元素

删除字典

• del dict[‘键名’] #删除某个键值对
• del dict #dict直接不存在
• dict.clear() #清空整个字典

字典转列表

• dict.keys() 不是列表是视图
• dict.values() 不是列表是视图

list(dict_info.keys())
list(dict_info.values())

• dict.items()
• dict.get(key, default=None)
  返回指定键的值，如果键不在字典中返回 default 设置的默认值

dict_info={'Mike': 95, 'Bob': 75, 'Tracy': 85}
dict_info.values()
dict_info.keys()
dict_info.items()
out：dict_values([95, 75, 85])
dict_keys(['Mike', 'Bob', 'Tracy'])
dict_items([('Mike', 95), ('Bob', 75), ('Tracy', 85)])

• 遍历key,value值

for item in dict_info.items():
    print(item)
out：('Mike', 95)
('Bob', 75)
('Tracy', 85)
for key,value in dict_info.items():
    print(key,value)
out：Mike 95
Bob 75
Tracy 85

可变/不可变

可变类型

• 列表list
• 字典dict
  不可变类型
• 数值类型 int long bool float
• 字符串 str
• 元组 tuple

a='abc' #a指向'abc'
a本身是一个变量 指向的对象的内容才是‘abc’
b=a.replace('a','A')
print(a) out:abc
print(b) out:Abc

函数

函数定义

def 函数名():
    函数代码

• 定义带有参数的函数

def add2num(a,b):
    c=a+b
    print(c)

• 调用带有参数的函数

add2num(11,22)
out:33

定义时的参数，用来接收参数用的，是形参
调用时的参数，用来传递给函数用的，是实参

函数参数

缺省参数

def name_age(name,age=18):
    print("Name=",name," age=",age)
name_age('zhangfei')#这个age缺省，调用default值
[out]:Name= zhangfei  age= 18
name_age('guanyu',35)
[out]:Name= guanyu  age= 35

不定长参数

def nolong(a,b,*args,**kwargs):
    print("a=",a)
    print("b=",b)
    print("args:",args)
    print("kwargs:",kwargs)

例1. args传入元组，kwargs传入字典

nolong(1,2,3,4,5,m=6,n=7,p=8)

[out]:a= 1
b= 2
args: (3, 4, 5) #元组
kwargs: {'m': 6, 'n': 7, 'p': 8} #字典

例2.

c=(3,4,5)
d={'m': 6, 'n': 7, 'p': 8}
nolong(1,2,*c,**d)
[OUT]a= 1
b= 2
args: (3, 4, 5)
kwargs: {'m': 6, 'n': 7, 'p': 8}

例3.

nolong(1,2,c,d)
a= 1
b= 2
args: ((3, 4, 5), {'m': 6, 'n': 7, 'p': 8})
kwargs: {}

引用传参

可变类型和不可变类型变量分别作为函数参数时，会有什么不同吗？

函数返回值