字符函数
title()首字母大写：Helo World!
upper()全大写：HELO WORLD!
lower()全小写：helo world!
转义字符
\n换行 \t --tabo位
删除空白
rstrip 删右空白
lstrip 删左空白
strip 删全空白
输出：print()
a=5 b=3
print(a//b) 切掉小数点
print(a**b) 5的三次方*b
修改元素
mylist[0] = "curry seth"
元素增加
.append("")
删除元素
del lang_list[0] 删除第0个元素
lang_list.pop 弹出元素并删除
mylist.remove("")指定删除元素
数组排序
print(len(mylist)) 输出数组里面有几个元素
mylist.sort() 按照字母顺序排序
mylist.reverse() 把元素顺序反过来
mylist.sort(reverse=False)
数组mylist.顺序排序（反过来=错误） 顺序排序
mylist.sort(reverse=True)
数组mylist.顺序排序（反过来=正确） 翻转
数组循环
for name in mylist
可随便取 数组
print("\t",name)前面空出四个空格，不然bug
循环索引
for i,item in enumerate(mylist): 有个冒号
print(i,item)前面有四个空格，不然报错
0 curry
1 harden
2 lebron
3 durant
4 kobe
range()的使用 range()范围
for val in range(5): 0 1 2 3 4
循环5次
for val in range(1,5): 1 2 3 4 (1,5-1) 循环四次
nums = list(range(1,5))
print(range(1,5)) range(1,5) 只看range
print(nums) [1,2,3,4] 这才是编码所需要用的数组
奇数数组
nums = list(range(1,11,2) 从1开始，到11结束，每+2输出
[1,3,5,7,9]
偶数数组
nums = list(range(2,11,2)
[2,4,6,8,10]
处理函数
nums = [1,3,5,7,9,2,4,6,8,10]
print(min(nums)) 1
print(max(nums)) 10
print(sum(nums)) 55
lambda写法
nums = [val*2 for val in range(1,5)]
将数组val输出的值*2
print(nums) [2,4,6,8,]
等价于 只是写法不一样，下面可读性更好
nums []
for val in range(1,5):
nums.append(val*2)
print(nums)
切片
切片定义 数组的一部分
print(fifa_ranking[0:3]) 输出数组第0个元素到第3-1个元素
print(fifa_ranking[:3]) 同上，可以不写0
print(fifa_ranking[2:]) 输出2+1个元素到最后一个元素
循环切片
for country in fifa_ranking[:3]: 输出0到3-1的元素
复制切片
top3 = fifa_ranking[:3] 输出了前三个元素
print(top3)
top3.append("Portugal") 增加了Portugal
print(top3)
元组
元组的定义 () 内容不可改变，但是可以被重新设置
数组[] 用中括号框为数组
tuple_sample = (1,2,3,5,8,13) 和数组一样，但是用小括号框起来
循环元组
for val in tuple_sample: 和数组一样可循环
print(val)
元组不变值
tuple_samele[0] =10 会报错，元组不可被改变
元组重新设置
tuple_sample =("a","b","c")
print(tuple_sample) 输出结果改变为('a', 'b', 'c')
if条件式
等于
for player in mylist:
if player =="lebron": 如果循环中等于lebron,不等于就不输出
print(player,is king.) 则只输出lebron后面加 is king.
结果：lebron is king.
不等于
for player in mylist:
if player != "lebron": 不等于lebron时输出，等于不输出
print(player,"is super star.") 加is super star
结果：
curry is super star.
harden is super star.
durant is super star.
kobe is super star.
列表存在判断 判断某一元素是否存在列表或数组中
if "harden" in mylist: 在就输出
print("哈登在这儿。")
结果：哈登在这儿。
if "westbrook" not in mylist: 不在就输出
print("神龟不在这儿。")
结果：神龟不在这儿。
多个条件判断
pts_Russia = 7
pts_Uruguay = 0
if pts_Russia > 6 or pts_Uruguay > 6: 或语句，满足其一，输出
print("俄罗斯或乌拉圭出线")
if pts_Russia > 6 and pts_Uruguay > 6: 和语句，双方满足才输出
print("俄罗斯，乌拉圭携手出线")
结果：俄罗斯或乌拉圭出线
各种if语句
if 如果满足某种条件 就执行某种处理
if-else 如果满足某种条件 就执行某种处理，否则走另一种处理
if-elif-else 如果满足某种条件 就执行某种处理，否则走另一种处理,如果前面两种都不满足，就走最后一种
if-elif-elif-else 循环
point = 35
if point > 30: 注意有冒号
print("MVP球星")
if point > 20:
print("绝对球星")
else: 否则
print("未来球星")
point =15
if point > 30:
print("MVP球星")
elif point >= 20: 如果 大于等于
print("绝对球星")
else:
print("未来球星")
if point > 30:
print("MVP球星")
elif point >= 20: 如果
print("绝对球星")
elif point >= 10: 如果
print("未来球星")
else:
print("普通球员")
字典
字典每个基本元素都包括两个部分：键（key） 和 键对应的值（value）。
键和值之间用冒号(:)分割，每对元素之间用逗号(,)分割，整个字典的数据在大括号{}中
字典中，键的内容是不可重复的。 键为不可变数据类型，值可以是任何数据类型。在这里，键只支持 字符串类型。
字典最大的优势就是能在海量数据下利用“键”快速查找出想要的值， 当有很多数据需要存储的时候，我们给每个值都打个标签，也就是“键”；想要调用这个值时，字典能够利用这个标签快速帮我们找到它。但是如果标签重复了，字典不知道哪个值才是对的，就会报错
使用字典
db_config = { 输出字典对象本身
"ip":"192.168.1.5"
键：值
key,val
"port":5432,
"uid":"postgres",
"pwd":"12345678"
}
print(db_config["ip"]) 输出字典里的ip
增加属性
db_config["timeout"] = 300 增加了timeout属性
修改属性值
db_config["timeout"] = 60 修改为60
遍历字典
items()循环每一个数据元素
for key,val in db_config.items():
方法items，存储到key和val里面 ip = 192.168.5
print(key,"is",db_config[key])
keys():循环数组的key
for key in db_config.keys():
print(key,"is",db_config[key]) ip is 192.168.5
根据key取到val
遍历所有的值
for val in db_config.values():
print(val)
活用字典
db_config = {
"ip":"192.168.1.5",
"port":5432,
"uid":"postgres",
"pwd":"12345678",
"options":{ 字典里面再定义一个字典
"timeout":300, 层级
"encode":"utf-8"
},
"drivers":["pgsql","Npgsql","jdbpgsql"]
} 数组属性↑
print(db_config["options"])
{'timeout': 300, 'encode': 'utf-8'} 可直接打印出内容
再定义的字典也能循环item()之类的
循环数组属性
driver = db_config["drivers"] 和循环普通的数组是一样的
for val in drivers:
print(val)
处理用户输入 isnumeric():
当调用input函数的时候，系统会停住不动，等待用户输入
myage = input("请输入你的年龄：") 请输入你的年龄
print("你的年龄是：",myage) 你的年龄是：
print("-------------") --------
年龄判断
if int(myage) > 30: 输入数字
print("现代老年人")
else:
print("加油啊，年轻人")
数字判断
isnumeric():
检测字符串是否只由数字组成,如果字符串中只包括数字,就返回Ture,否则返回False
if myage.isnumeric():
if int(myage) > 30:
print("现代老年人")
else:
print("加油啊，年轻人")
else:
print("火星年龄")
while循环
while i <= 8: i小于等于8
print(i)
i += 1 没有这行就进入死循环了 i+1,返回第一行继续循环
break函数
result = 0
i = 1
while i<= 8:
result += i i赋值给result
i += 1
if i> 5:
break 退出
print("result=",result)
continue函数
continue 的功能和 break 有点类似,区别是 continue 只是忽略当次循环的剩下语句,接着开始下一次循环,并不会中止循环;而 break 则是完全中止循环本身
i = 1
while i <=8:
if i % 2 == 1: i取余2，如果等于1， 不等于就输出
i += 1 i就+1
continue 返回去继续循环
print(i)
i += 1
whlie高级
pop()从后面开始弹出数组元素（去掉）
循环数组
mylist = ["curry","harden","lebron","durant","kebe"]
while mylist: 循环mylist
player = mylist.pop() 循环后弹出元素
print(player) 循环完了等于元素也没了
kebe
durant
lebron
harden
curry
同等的for写法
for player in mylist:
print(player)
定义函数
def 开始函数定义,紧接着是函数名,括号内部为函数的参数
def helo1():
print("helo world.")
helo1() 直接输出 helo world.
声明参数
def helo2(name): 传一个name
print("helo",name) 不传参直接报错
helo2("koma") 传一个koma，结果为helo koma
上传数字也可以
ef add(x,y):
print(x+y)
add(10,13) 结果为26
参数默认值
def helo3(name="koma"):
有上传的话，就使用上传值，没有就默认为koma
print("hi",name)
helo3() hi koma
helo3("mike") hi mike
函数返回值
返回数值
def add(x,y): 定义函数add，
return x + y 将数值x y返回x+y
print(add(10,20)) 30
print(add(30,50)) 80
返回字符
def makeDBString(ip,dbname,uid,pwd):
connString =""
connString += "Server="+ip+";"
connString += "Database="+dbname+";"
connString += "Uid="+uid+";"
connString += "Pwd="+pwd+";"
return connString
print(makeDBString 把这几个上传到第一行对应位置输出("192.168.0.10","myblog","koma","12345678"))
返回字典 {}括起来的是字典
db = makeDBString("192.168.0.10","myblog","koma","12345678")
print(db)
{'Server': '192.168.0.10', 'Database': 'myblog', 'Uid': 'koma', 'Pwd': '12345678'}
print(db["Server"])
192.168.0.10
print(db["Database"])
myblog
print(db["Uid"])
koma
print(db["Pwd"])
12345678
传递任意参数
def add(*num):
在这个普通的函数参数之前加*，代表这接收的是个数组
result = 0 让result=0
for val in num:
result += val 累加
return result
result_sum = add(1,2,3,) 结果为6
传递关键字参数
def sendmail(**data): 传进来的是字典
for key,val in data.items():
循环字典的每一个key和val输出
print(key,":",val)
sendmail(
subject="Pyhon真不错",
content="我最近学习Python,感觉不错,赞一个！",
to="test01@komavideo.com",
cc="xiaoma@komavideo.com",
try_times=5
)
subject : Pyhon真不错
content : 我最近学习Python,感觉不错,赞一个！
to : test01@komavideo.com
cc : xiaoma@komavideo.com
try_times : 5
>>> result_sum = add(1,2,3,)
导入模块
建一个文件，里面写入函数
def add(x,y):
return x + y
def minus(x,y):
return x - y
import func
模块在一个文件夹里面就可这样导入，不然要加模块所在路径
print(func.add(10,20)) 前面加上func.add
print(func.minus(10,20))
导入模块并指定别名
import func as mufunc
让他名字为myfunc
print(myfunc.add(10,20))
print(myfunc.minus(10,20))
导入模块函数
form func import * 相当于在本文件中定义了这两个函数
print(add(10,20)) 前面就不用加名字了
print(minus(10,20))
如果有两个模块，两个模块都有相同名字的函数的话，可能会混乱
创建使用类
class Player(): ():定义了类的内容题
def __init__(self,name):
定义python类的时候第一个方法的参数必须是self
__init__初始化构造器函数，用于初始化类的各种属性和变量
self.name = name
self相当于this，把name赋给self模板集的name变量
def sayHelo(self):
print("helo",self.name.title())
def intro(self):
print("I am player.")
curry = Player("curry") 这是实例化了一个Play对象
Player是类名，跟着的（）是他的构造器，传入curry，self不用传,当他是隐形参数
print(curry.name)打印这个curry里面的name
886
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
