Python
- 安装国内的镜像包：pip config set global.index-url Simple Index
豆瓣：http://pypi.douban.com/simple/
- pip install 库名 -i 国内镜像加速器地址。
- pip install 加库名 #安装库
库一般安装在python下的scripts下
d: #换盘
- pip list #显示安装的库
- pip freeze #以指定的格式显示安装的库
- pip uninstall ipython #删除安装的库
- 在桌面创建一个文本文档，将后坠名改为py，写入代码后打开终端输入：python 路径
- exit() #退出或ctrl +z
- ipython进入高亮显示
- 单行注释：#
- 多行注释：‘‘’ ‘’’
- 定义变量语法：变量名=变量值 =为赋值
- int(整型) flout（小数） boolean(布尔)true真 false假
string（字符串）
list（列表） tuple（元组） dictionary（字典）
a = 0.3
print(type(a))#打印一个数的数据类型
- 列表输入格式：
name_list = ["kk",'ss']
print(name_list)- 元组输入格式：
age_tuple = (12,13,15)
print(age_tuple)- 字典的输入格式：
person = {"name":"da","age":"18"}
print(person)- 变量赋值不允许单引号套单引号或双引号套双引号
- 标识符命名规范：
（1）. 标识符由字母，下划线和数字组成，不能以数字开头。
(2). 严格区分大小写：
Animal = 1
print(animal) #错误
（3）不能使用关键字：
false continue from not none def global or true
del if pass and elif import raise as else
in return assert except is try break finally
lambda while class for nonlocal with yield
- 选中ctrl+/全部注释
- 标识符或变量的命名要做到顾名思义。
小驼峰式命名法(lower camel case) : 第一个单词以小写字母开始; 第二个单词的首字母大写，例如: myName、aDog
大驼峰式命名法 (upper camel case) :每一个单字的首字母都采用大写字母，例如: FirstName.
LastName.
还有一种命名法是用下划线”_”来连接所有的单词，比如send buf.
- 转换数据类型：
a = 1.3
print(type(a))
b = int(a)
print(b)
print(type(b))- True代表1，False代表0
- 将字符串转为浮点数（在我们爬取网页的时候大多数都是字符串）
c = "1.5" #加引号为字符串不加为浮点数
print(type(c))
b = float(c)
print(b)
print(type(b))- Str字符串类型
- int改为浮点数后面加.0
- 转为字符串：
a = 80
print(type(a))
b = str(a) #字符串要用str表示不是string
print(b)
print(type(b))- 将布偶类型转为字符串为：True
s1 = True
print(type(s1))
s2 = str(s1)
print(s2)
print(type(s2))- 转换为布尔类型：
a = -1
print(type(a))
b = bool(a) #如果对非0的整数（包含负数和正数）转为布尔型，都为True
print(b) #在整数范围内0强制转换为bool类型结果为False
print(type(b))- 浮点数转为布尔累：
a = 1.1
print(type(a))
b = bool(a) #将浮点数转为bool类型，正的浮点数和负的浮点数结果为True
print(b) #如果是0.0结果为False
print(type(b))- 将字符串转为布尔类型：
a = "就这"
print(type(a))
b = bool(a) #只要字符串中有内容，那么就返回True空格同
print(b) #如果是空字符串，那么返回False
print(type(b))- 将列表转为布尔类型：
a = ["z","s"]
print(type(a))
b = bool(a) #只要列表中有数据，那么强制类型转换为bool的时候，返回True
print(b) #如果是空列表，那么返回False
print(type(b))- 将元组转为布尔类型:
a = ("a","b","c")
print(type(a))
b = bool(a) #只要元组中有数据，那么强制类型转换为bool的时候，返回True
print(b) #如果是空元组，那么返回False
print(type(b))- 将字典转为布尔类型：
a = {"name","zhang"}
print(type(a))
b = bool(a) #只要字典中有数据，那么强制类型转换为bool的时候，返回True
print(b) #如果是空字典，那么返回False
print(type(b))- 什么情况下是False
#什么情况是
print(bool(0))
print(bool(0.0))
print(bool(""))
print(bool(''))
print(bool(())) #元组
print(bool({})) #字典
print(bool([])) #列表- 算数运算符：
a = 2
b = 3
print(a+b)
print(a-b)
print(a*b)
print(a/b)
print(a//b) #整除取整数
print(a%b) #a对b取余数
print(a**b) #a的b次方- 混合，优先级为：**高于*，/，%，//高于+，-，为了避免歧义，建议用括号来处理优先级。
- 字符串的加法是进行拼接：
a = "123"
b = "456"
print(a+b) #123456- 在python中加号两端都是字符串才可以进行加法运算
- 字符串的乘法：
a = "哎嗨"
b = 4
print(a*b) #字符串的乘法是将字符串重复输出多少次- 赋值运算符：=
把=号右边的结果赋给左边的变量，如num=1+2*3，结果num的值为7
- 多个变量赋值：b=c=10， a，b，c=1，2，3
- 复合赋值运算符：
a = 2
a = a + 2 #a+=2
print(a) #4
- b*=2等于b=b*2
c/=3等于c=c/3
d//=2等于d=d//2
e%=3等于e=e%3
f**=2等于f=f**2
- 比较运算符：
比较运算符返回的都是bool类型的数据：true或false
a = 2
b = 3
print(a!=b)#返回True
- == #等于
!= #不等于
- 大于
< 小于
>= 大于等于
<= 小于等于
- 大于等于只要满足一个返回True
- <>是python2的等于号python3被遗弃
- 逻辑运算符：
and与 or或 not非
print(3>1 and 3<1) #返回False- And两边的数据必须两边都是True才会返回True,只要一边或两边都是False那么都返回False
- Or有真则真，两边都是False返回Flse
- not:
print(not True) #not非 取反
print(not (1>2)) #返回True- and的性能优化
a = 21
a>22 and print("efrgv")#没有输出
#and性能优化，当and前面的结果为False的情况下后面的代码不运行- or性能优化：
a = 21
a>2 or print("efrgv")#没有输出
#and性能优化，当or一边为ture的时候不执行，反之执行and短路与
or短路或
- 输入输出：
age = 18
name = "zhfef"
print("我的名字是%s，我的年龄是%d" % (name,age))#s代表字符串，d代表数值- 输入：
name = input("请输入你的名字")
print("我的名字是%s" % name)- If 语句：
If的判断条件：
代码（如果判断条件为true的时候执行下面的内容）
age=19
if age>18:
print("那么你可以上天了")
age = input("请输入你的年龄")
if int(age) > 18: #默认为scr类型不能和int比较
print("那么你可以上网了")- else语句格式：
if 判断条件：
判断条件为true的时候执行的代码
否则else：
判断条件为false的时候执行的代码
age = input("请输入你的年龄")
if int(age) > 18: #默认为scr类型不能和int比较
print("那么你可以上网了")
else:
print("回家写作业去")- elif语句：
score =int(input("请输入你的成绩"))
if score >= 90:
print("优秀")
elif socre>=80:
print("良好")
elif socre>=70:
print("中等")
elif socre>=60:
print("及格")
else:
print("不及格")- 遍例：
s = "dsffvev"
for i in s: #i是字符串中一个又一个变量，s表示遍利的数据
print(i)- 遍例数字：
for i in range(5): #遍例0到四的底数
print(i)- for I in range(起始值，结束值，步长 )
步长：数字间的间隔。
- 便利数组：
a_list=["jz","nim","wc"]
for i in a_list:
print(i)- 技巧：
a_list=["jz","nim","wc"]
for i in range(len(a_list)): #len(a_list)判断列表中的元素个数。
print(i)- 字符串的高级
- len()判断一个字符串的长度：
s = "fdref"
print(len(s))- 查找内容：find
s1 = "china"
print(s1.find("a")) #a在变量中遍历的位置- 判断:startswith,endswith，判断字符串是不是以谁谁谁开头/结尾
s2 = "sfddsfew"
print(s2.startswith("s")) #查看是否以s开头是返回True否则返回False
print(s2.endswith("w")) #判断是否以w结尾是返回True否则返回False- Count统计某些字符出现次数：
s3 = "hhhss"
print(s3.count("h")) #统计h出现次数- 替换内容:replace
s4 = "cccdd"
print(s4.replace("d","c")) #将d换成c- 切割字符串:split 通过参数的内容切割字符串
s5 = "1#2#3#4#"
print(s5.split("#")) #将#切割掉- 修改大小写:upper,lower
s6 = "sfefwef"
print(s6.upper()) #转大写
s7 = "GRTEG"
print(s7.lower()) #转小写- 空格处理:strip 去空格
s8 = " a "
print(s8.strip()) #返回a
print(len(s8.strip())) #返回一- 字符串的插入：join
s9 = "f"
print(s9.join("ferfr")) #往后面的ferfr中一一插入- 列表的修改：
city_list = ["上海","北京","深圳","武汉"]
print(city_list)
city_list[3] = ["甘肃"]#可通过下标修改，但列表中的下标从0开始
print(city_list)- In判断一个元素在不在列表中：
food_list = ["火锅","小笼包","小鸡炖蘑菇"]
food_list= input("请输入你想吃的食物")
if food_list in food_list:
print("在")
else:
print("不在")- Not in （不存在）如果不存在返回true否则返回为false
ball_list = ["足球","篮球","乒乓球"]
ball_list = input("请输入你喜欢的球类")
if ball_list not in ball_list:
print("有")
else:
print("没有")- 列表高级：
del根据下标删除元素：
a_list = [1,2,3,4,5,6]
del a_list [3] #删除4
print(a_list)pop删除列表中的最后一个元素：
a_list = [1,2,3,4,5]
a_list.pop() #返回[1,2,3,4]
print(a_list)rewove：根据元素的值删除
c_list = [1,2,3,4,5]
c_list.remove(3) #返回[1,2,4,5]删除的是数据不是下标
print(c_list)- 元组的高级：
元组的元素不可修改：c_tuple [4] = 3 不可
定义只有一个元素的元组时，需要在唯一的元素后面加一个逗号：
C_tuple = [3,]
- 切片：是指对操作的对象截取其中一部分的操作，字符串，列表，元组都支持。
s ='Hello World!"
print(s)
print(s[4]) # o 字符里的第4个元素
print(s[3:7]) # lo w 包含下标 3，不含下标 7 #左闭右开区间
print(s[1:]) # ello word! 从下标为1开始，取出 后面所有的元素 (没有结束位)
print(s[:4])# He11 从起始位置开始，取到 下标为4的前一个元素 (不包括结束位本身)
print(s[1:5:2]) # el 从下标为1开始，取到下标为5的前一个元素，步长为2(不包括结束位本身)
- 字典的高级：
- 字典的查询：
proson = {"name":"zhangshan","age":18}
print(proson["name"])#查看name
print(proson.get("name")) #用get查看name
#使用get访问字典中不存在的元素时会返回None（空值）。而第一种方式则会直接报错- 字典的修改：
proson = {"name":"zhabgsan","age":18}
proson["name"]= "法外狂徒"
print(proson) #输出{'name': '法外狂徒', 'age': 18}- 字典的添加：
proson = {"name":"zhabgsan"}
proson["age"] = 14
print(proson) #返回{'name': 'zhabgsan', 'age': 14}
proson["name"] = "张三"
print(proson) #返回{'name': '张三', 'age': 14}
#如果使用变量名称数据在字典中不存在，那么就会变成新增元素，如果存在那么就会变成修改这个名称的数据- 字典的删除：、
del删除字典中的一个元素：
person = {"name":"zhangsan","age":19}
del person["age"]
print(person)删除整个字典：
person = {"name":"zhangsan","age":19}
del person
print(person)- Clear清空字典
person = {"name":"zhangsan","age":19}
print(person)
person.clear() #清空所有数据，保留字典结构
print(person)- 字典的遍历：
Key：
person = {"name":"zhangsan","age":19,"sex":"男"}
for key in person.keys(): #key()方法获取字典中的Key值，key是一个变量的名字，可以随便取。
print(key)
person = {"name":"zhangsan","age":19,"sex":"男"}
for key in person.keys(): #key()方法获取字典中的Key值，key是一个变量的名字，可以随便取。
print(key)value:
person = {"name":"zhangsan","age":19,"sex":"男"}
for value in person.values(): #value（）是获取字典中所有value的值，value是一个变量
print(value)value和key：
person = {"name":"zhangsan","age":19,"sex":"男"}
for key,value in person.items():
print(key,value)遍历字典中的项/元素：
person = {"name":"zhangsan","age":19,"sex":"男"}
for itme in person.items():
print(item)- 函数的定义和使用：
- def定义函数：
def f1():
print("就")
print("这")
print("呀")
f1()- 函数的参数：
def sum(a,b):
c=a+b
print(c)
sum(1,2)位置参数按照位置一一对应关系传递参数
- 关键字参数：
Sum(b=100,a=300)
- 定义时小括号中的参数，用来接收参数用的，称为“形参”
调用时小括号中的参数，用来传递给函数用的，称为“实参
- 函数的返回值： 关键字：return
def sum(a,b):
c=a+b
return c
a=sum(123,234)
print(a)- 局内变量：
在函数内部定义使用，而外部不可以用
def f1():
a=1
print(a)
f1()- 全局变量：
- 定义在函数外部的变量，可以在函数的外部使用，也可以在内部使用。
a = 1
print(a)
def f1():
print(a)
f1()- 文件的打开与关闭：
Open（文件路径，访问模式）
模式：w为可写，r为可读
创建文件：
open("test.txt","w")- 打开文件写入文件：
fp=open("test.txt","w")
fp.write("hello world")- 文件写完要关闭
fp=open("a.txt","w")
fp.write("holle")
fp.close() #关闭文件- Print(“就\n“ * 5) #换行输出就五次
- 读数据：
fp = open("test.txt","r")
content = fp.read() #read默认一字节一字节的读效率很慢
print(content)- Readline是一行一行的读，只能读取第一行
content = fp.readline()
print(content)- Readlines可以安照行来读取，但是会将所有数据都读取到一个列表中，是一行一行的数据
content = fp.readlines()
print(content)- 异常：
try:
fp = open("text.txt","r")
fp.read()
except FileNotFoundError:
print("系统正在升级")- 序列化和反序列化：设计一套协议，按照某种规则，把内存中的数据转换为字节序列，保存到文件，这就是序列化。反之，从文件中的字节序列恢复到内存中，就是反序列化。
- damps()
fp = open("test.txt","w")
name_list = ["zs","ls"]
import json #导入json模块到该文件中
names = json.dumps(name_list) #序列化#将python对象变成json字符串
fp.write(names) #将names写入文件中
fp.close()
print(names)
print(type(names))- damp
fp = open("test.txt","w")
name_list = ["zs","ls"]
import json
json.dump(name_list.fp)
fp.close()- 反序列化：将json的字符串变为python的一个对象
- Loads
fp = open("a.txt","r")
content = fp.read()
print(content)
print(type(content))
import json
resalt = json.loads(content)
print(resalt)
print(type(resalt))- Load
fp = open("a.txt","r")
import json
result = json.load(fp)
print(result)
print(type(result))
fp.close()load加载的是文件，而loads加载的是数据
标签：fp,name,python,基础,age,list,print,type From： https://blog.csdn.net/qq_74922407/article/details/141259556