1.字典 -- dict
字典是无序,可变的
键:使用不可变数据类型(可哈希),键是唯一的
值:可以任意
增加
dic["键"] = "值" # 暴力添加
dic.setdefault("键","值") # 存在不添加
删除
del dic["键"]
dic.pop("键")
dic.clear()
改
dic["键"] = "值"
dic.update("要更新的字典")
查
for 循环查询的是字典的键
get("键") #存在返回字典中键对应的值,不存在返回None
dic["键"] # 存在返回字典中键对应的值,不存在报错
其他操作
keys -- 获取字典中所有的键 存放在一个高仿列表中
values -- 获取字典中所有的值 存放在一个高仿列表中
items -- 获取字典中所有的键和值 存放在一个高仿列表里的元组(元组第一个元素:键,第二元素:值)
解构
a = 10
b = 20
a,b = b,a
字典的嵌套
dic = {1001:["周杰伦","林俊杰"],
1002:{"汪峰":{"前妻1":["大烧饼"],"前妻2":["熊大","熊二"],"国际章":"肉丝"}},
1003:{"陈冠希":["阿娇","阿萨","张柏芝"]},
1004:{"韦小宝":[{"教主夫人":["教主"]},
{"阿珂":"刺客"},
{"双儿":"天地会"},
{"爱心觉罗建宁":"公主"},
{"独臂神尼":{"韦小宝师父":{"兰陵王":"隐身"},"花木兰":[
"唧唧复唧唧","木兰是战士",{"爸爸":["花和尚"]}]
}},
{"陈圆圆":"丈母娘"},{"穆建平":"小郡主"}]},
1005:{"常鑫":["大黑哥","大烧饼","吃大煎饼","肉夹馍","自行车","井盖",]}
}
print(dic)
print(dic[1004]["韦小宝"][0]["教主夫人"][0])
print(dic[1005]["常鑫"][-1])
print(dic[1002]["汪峰"]["前妻2"][-1])
print(dic[1004]["韦小宝"][4]["独臂神尼"]["韦小宝师父"]["兰陵王"])
print(dic[1004]["韦小宝"][4]["独臂神尼"]["花木兰"][2]["爸爸"][0])
# 查找的时候一层一层的通过键进行查找
# 键
小数据池--缓存机制(驻留机制)
== 判断两边内容是否相等
a=10
b=10
print(a==b)
Ture
is 是
a=10
b=10
print(a is b) # is 判断基于内存地址进行判断
#查ID
print(id(a))
print(id(b))
小数据池的数字范围:-5~256
a = -2.5 * 2
b = -2.5 * 2
print(id(a))
print(id(b))
a = "alex你好" *2
b = "alex你好" *2
print(id(a))
print(id(b))
代码块:一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块
支持:
数字:
在同一代码块下 只要内容相同就采用相同的内存地址(-5以后就不是)
# 数字在做乘法的时候范围 -5 ~ 256 ****
数字在做乘法的时候不能使用浮点数
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
# 乘法的时候总长度不能超过20 ****
乘法的时候中文,特殊符号乘以1或0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址
小数据池
# 数字: -5 ~ 256 ****
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
# 乘法的时候总长度不能超过20 ****
乘法的时候中文,特殊符号乘以0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址
小数据池的验证方法,必须脱离代码块才能进行验证
先执行代码块的规则,在执行小数据的规则 --(驻留机制)
必会:
#重点重点
# == 判断等号两边的值是否相等 ****
# is 判断两边的内存地址是否相等 ****
总结
1.1代码块: 一个文件,一个函数,一个类,一个模块,终端中每一行
1.1.1 数字: -5 ~ 256
1.1.2 字符串: 乘法时总长度不能超过20
1.1.3 布尔值: 内容相同内存地址相同
1.2 小数据池:
1.2.1 数字: -5 ~ 256
1.2.2 字符串: 乘法时总长度不能超过20
1.2.3 布尔值: 内容相同内存地址相同
1.3 先执行代码块后执行小数据池
1.4 == is
1.4.1 == 判断等号两边值是否相等
1.4.2 is 判断两边的值内存地址是否相等
深浅拷贝--复制
# 面试必问:赋值,浅拷贝,深拷贝
# 浅拷贝=修改第一层元素不改变,其它改变.
# 深拷贝=修改任何位置,另外一个不改变.
lst = [1,2,3,[5,6,7]]
lst1 = lst
print(lst1)
print(lst)
lst[-1].append(8)
print(lst1)
print(lst)
lst1 = lst.copy() # 新开辟一个空间给lst1
print(lst[-1])
print(lst1[-1])
print(id(lst1[-1]))
print(id(lst[-1]))
浅拷贝的时候
只会开辟一个新的容器列表,其他元素使用的都是源列表中的元素
# 浅拷贝=修改第一层元素不改变,其它改变.
lst = [1,2,3,[5,6,7]]
lst1 = lst.copy() # lst1 = lst.copy()
lst1[-1].append(8)
print(lst)
print(lst1)
深拷贝
不可变的数据类型公用,可变的数据类型重新开辟一个空间,对源数据进行修改,深拷贝的内容不进行改变
# 深拷贝=修改任何位置,另外一个不改变.
import copy #导入
lst = [1,2,3,[5,6,7]]
lst1 = copy.deepcopy(lst) # 深拷贝 lst1 = copy.deepcopy(lst)
lst[-1].append(8)
print(lst)
print(lst1)
总结
# 浅拷贝的时候只拷贝第一层元素
# 浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变
# 浅拷贝在替换第一层元素(可变数据类型)的时候,拷贝出来的新列表不进行改变
# 浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变
# 深拷贝开辟一个容器空间(列表),不可变数据公用,可变数据数据类型(再次开辟一个新的空间)
# ,空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间
测试代码
#浅拷贝
s = [1, 2, 3, [4, 5, 6]]
s1 = s.copy()
s[-1] = 11111
print(s)
print(s1)
#深拷贝
s=[1,2,3,[4,5,6]]
import copy
s1=copy.deepcopy(s)
s[-1][1]=11111
print(s)
print(s1)
集合--set
没有值的字典 无序--不支持索引
**** 天然去重
定义集合
s = {1,"alex",False,(1,2,3),12,1,12,4,6,32,2,4}
print(s)
面试题:
lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst)))
s = {1,2,3,4}
增:
s.add("67") #只能添加一个
print(s)
s.update("今天") # 迭代添加
print(s)
删:
print(s.pop()) # pop有返回值
print(s)
s.remove(3) # 指定元素删除
print(s)
s.clear() # 清空 -- set() 空集合
print(s)
改:
先删在加
查:
for i in {1,2,3}:
print(i)
其他操作:
s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}
print(s1 & s2) # 交集
print(s1 | s2) # 并集
print(s1 - s2) # 差集
print(s1 ^ s2) # 反交集
print(s1 > s2) # 父集(超集)
print(s1 < s2) # 子集
print(frozenset(s1)) # 冻结集合 更不常用
dic = {frozenset(s1):1}
print(dic)
基础类型补充
str:不可变
1.首字母大写
name = "alex"
name1 = name.capitalize()
print(name1)
2.每个单词首字母大写
name = "alex wusir"
print(name.title())
3.大小写反转
name = "Alex"
print(name.swapcase())
4.居中--填充
name = "alex"
print(name.center(20,"-"))
5.查找 从左向右 只查找一个
name = "alelx"
print(name.find("b")) #find查找不存在的返回-1
print(name.index("b")) #index查找不存在的就报错
6.拼接
name = "al3x"
# print("_".join(name)) ***
7.格式化
1.%s
2.f
3.name.format()
name = "alex{},{},{}"
print(name.format(1,2,3)) # 按照顺序位置进行填充
name = "alex{2},{0},{1}"
print(name.format("a","b","c")) # 按照索引值进行填充
name = "alex{a},{b},{c}"
print(name.format(a=1,c=11,b=67)) # 按照关键字进行填充
8.+ * 开辟新的空间
name = "alex"
name1 = "wusir"
print(id(name))
print(id(name1))
print(id(name + name1))
list:
定义方法
list("123")
其他方法
lst = [1,2,23,234,435,36,23,213421,421,4231,534,65]
lst.sort() # 排序 (升序)
print(lst)
lst = ["你好","我好"]
lst.sort() # 排序 (默认升序)
print(lst)
lst.sort(reverse=True) # 降序
print(lst)
lst = [1,2,3,4453,5,6,7]
print(lst[::-1])
lst.reverse() # 反转
print(lst)
lst = [1,2,3,4,5123,21345,231123,4,1235,234,123]
lst.sort()
lst.reverse()
print(lst)
面试题
lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)
lst = [1,[]]
new_lst = lst * 5
new_lst[0] = 10
print(new_lst)
lst = [1,[]]
new_lst = lst * 5
new_lst[1] = 10
print(new_lst)
方式一:
lst.extend(lst1)
print(lst)
方式二:
print(lst+lst1)
new_lst = lst * 5
print(id(new_lst[0]), id(new_lst[0]))
lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)
tuple
tu = ("12") # 数据类型是()中数据本身
print(type(tu))
tu = (1,) # (1,)是元组
print(type(tu))
元组 + * 不可变共用,可变也共用
dict
定义一个字典
print(dict(k=1,k1=2))
随机删除:popitem
dic = {"key":1,"key2":2,"key3":56}
print(dic.popitem()) # 返回的是被删除的键值对(键,值)
print(dic)
python36 默认删除最后一个
dic = {}
dic.fromkeys("123",[23]) # 批量添加键值对{"1":[23],"2":[23],"3":[23]}
print(dic)
dic = dict.fromkeys("123456789",1) # 批量添加键值对"键是可迭代对象",值 -- 会被共用
dic["1"] = 18
print(dic)
set
# set() -- 空集合
# {} -- 空字典
# 定义集合:
# set("alex") # 迭代添加的
bool: False
数字: 0
字符串: ""
列表:[]
元组:()
字典:{}
集合: set()
其他: None
数据类型之间转换
list tuple
tuple list
str list
name = "alex" print(name.split())
list str
lst = ["1","2","3"] # print(''.join(lst))
dict -- str
dic = {"1":2}
print(str(dic),type(str(dic)))
print(dict("{1:1}"))
set - list
list - set
# python数据类型:
# 可变:
# list ,dict ,set
# 不可变:
# int bool str tuple
# 有序:
# list,tuple,str,int,bool
# 无序:
# dict,set
# 取值方式:
# 索引: str list tuple
# 直接: set ,int ,bool
# 键: dict
二次编码
密码本
ascii -- 没有中文
gbk -- 英文 8b(位) 1B(字节) 中文 16b 2B
unicode -- 英文16b 2B 中文32b 4B
utf-8 -- 英文8b 1B 欧洲16b 2B 亚洲24b 3B
name = "你好啊"
s1 = name.encode("utf-8") # 编码 9
s2 = name.encode("gbk") # 编码 6
s2 = s1.decode("utf-8") # 解码
print(s2.encode("gbk"))
# 以什么编码集(密码本)进行编码就要用什么编码集(密码本)解码
以后会遇见的坑坑坑
循环
lst = [1,2]
for i in lst:
lst.append(3)
print(lst) # 死循环
删除列表的坑
lst = [1,2,3,4]
for i in lst:
lst.pop()
print(lst)
lst = [1,2,3,4]
for i in lst:
lst.pop(0)
print(lst)
lst = [1,2,3,4]
for i in lst:
lst.remove(i)
print(lst)
成功删除的方式
lst = [1,2,3,4,6]
for i in range(len(lst)):
lst.pop()
print(lst)
lst = [1,2,3,4,6]
for i in range(len(lst)-1,-1,-1):
del lst[i]
print(lst)
lst = [1,2,3,4,6]
for i in range(len(lst)):
del lst[-1]
print(lst)
lst = [1,2,3,4,5,6]
lst1 = lst.copy()
for i in lst1:
lst.remove(i)
print(lst)
删除字典的坑
dic = dict.fromkeys("12345",1) # 字典的迭代的时候改变了原来的大小(不能加不能删)
for i in dic:
dic[i] = "123"
print(dic)
dic = dict.fromkeys("12345",1)
dic1 = dic.copy()
for i in dic1:
dic.pop(i)
print(dic)
# 集合和字典都是迭代的时候不能改变原来的大小
文件操作
理论性知识
"萝莉小姐姐电话号.txt"
open() # 打开
file # 文件的位置(路径)
mode # 操作文件的模式
encoding # 文件编码方式
f # 文件句柄
f = open("萝莉小姐姐电话号",mode="r",encoding="utf-8")
print(f.read())
f.close()
操作文件:
1. 打开文件
2. 操作文件
3. 关闭文件
文件操作的模式:
r,w,a (重要)
rb,wb,ab (次要)
r+,w+,a+ (没啥用)
f = open("文件的路径(文件放的位置)",mode="操作文件的模式",encoding="文件的编码") # 内置函数
f(文件句柄)
重要知识:r读,w写,a加 (重要) 内容
R操作 读
f = open("萝莉小姐姐电话号",mode="r",encoding="utf-8")
print(f.read()) #全部读取
print(f.read(5)) #按照字符进行读取
print(f.read())
print(f.readline()) # 读取一行内容,自动换行
print(f.readline()) # "常鑫你就是大帅比\n"
print(f.readline().strip()) #去除换行符
print(f.readlines()) # 一行一行的读取,存放在列表中
解决大文件:
for i in f:
print(i) # 本质就是一行一行进行读取
print(f.readline())
print(f.readline())
print(f.readline())
W操作 写
w分为两步:
1.先清空文件
2.写入文件
f = open("萝莉小姐姐电话号","w",encoding="utf-8")
f.write("123456789\n")
f.write("123456789\n")
f.write("123456789\n")
f.write("123456789\n")
路径
1.绝对路径 -- C:\user\meet\python24\萝莉小姐姐电话号
2.相对路径
绝对路径方式打开文件
f = open("F:\s24\day08\萝莉小姐姐电话号","r",encoding="utf-8")
print(f.read())
相对路径方式打开文件
f = open("../day03/萝莉小姐姐电话号","r",encoding="utf-8")
print(f.read())
../ 返回上一层
f = open(r"C:\user\net\s24\day03\萝莉小姐姐电话号","r",encoding="utf-8")
路径转义:
1."\\"
2.r"C:\user\net"
推荐使用相对路径 (*****)
s = "[1,'2',3,4]"
print(s)
print(repr(s)) # repr -- 显示数据原生态
A操作:追加写 加
在源文件的基础上进行添加
f = open("../day03/萝莉小姐姐电话号","a",encoding="utf-8")
f.write("138383848\n")
f.write("138383850\n")
次要知识:rb,wb,ab (次要) 字节
rb 读 字节
f1 = open("1.jpg","rb")
print(f1.read()) # 全部读取
print(f1.read(3)) # 按照字节读取
wb 写 字节
f = open("3.jpg","wb")
f.write(f1.read())
ab 加 字节
f = open("2.jpg","ab")
f.write("你好啊".encode("utf-8"))
f = open("2.jpg","rb")
print(f.read())
不重要: +操作
R+ 读写-先读后写
错误的操作 (坑)
f = open("萝莉小姐姐电话号","r+",encoding="utf-8")
f.write("常鑫你太美")
print(f.read())
正确的操作:
f = open("萝莉小姐姐电话号","r+",encoding="utf-8")
print(f.read())
f.write("常鑫你太美")
w+ 清空写 读
f = open("萝莉小姐姐电话号","w+",encoding="utf-8")
f.write("常鑫你太美")
print(f.tell())
f.seek(15)
print(f.tell())
print(f.read())
a+ 追加写 读
f = open("萝莉小姐姐电话号","a+",encoding="utf-8")
f.write("常鑫你太美")
print(f.tell()) # 字节数
print(f.seek(0,0)) # 0将光标移动到文件的头部
print(f.read())
其他操作:
tell 查看光标 --- 返回的是字节数
seek 移动光标
1.seek(0,0) -- 移动到文件的头部
2.seek(0,1) -- 当前位置
3.seek(0,2) -- 移动到文件的末尾
4.seek(3) -- 按照字节进行移动(按照编码集,自己进行计算)
f = open("萝莉小姐姐电话号","r",encoding="gbk")
print(f.read(3)) # 字符
f = open("萝莉小姐姐电话号","rb")
print(f.read(3)) # 字节
f = open("萝莉小姐姐电话号","r",encoding="gbk")
print(f.read(3)) # 字符
错误操作
f = open("萝莉小姐姐电话号","r",encoding="gbk")
f.seek(-1)
print(f.read())
文件修改
f = open("萝莉小姐姐电话号","r",encoding="gbk")
s = f.read()
s1 = s.replace("你太美","吃煎饼")
f1 = open("萝莉小姐姐电话号","w",encoding="gbk")
f1.write(s1)
with 关键字 open("萝莉小姐姐电话号","r",encoding="gbk") as f:
文件操作的具体内容
w,a 检测有文件就操作,没文件就创建
with open("萝莉小姐姐电话号","r",encoding="gbk")as f,\
open("萝莉小姐姐电话号.txt","w",encoding="gbk")as f1:
for i in f:
s1 = i.replace("大烧饼","井盖")
f1.write(s1)
import os
os.rename("萝莉小姐姐电话号","萝莉小姐姐电话号.bak")
os.rename("萝莉小姐姐电话号.txt","萝莉小姐姐电话号")
with open("萝莉小姐姐电话号","r",encoding="gbk")as f:
pass # 缩进里操作文件
print(f.read()) # 文件及已经关闭了
总结
1.字典 -- dict
字典是无序,可变的
键:使用不可变数据类型(可哈希),键是唯一的
值:可以任意
增加
dic["键"] = "值" # 暴力添加
dic.setdefault("键","值") # 存在不添加
删除
del dic["键"]
dic.pop("键")
dic.clear()
改
dic["键"] = "值"
dic.update("要更新的字典")
查
for 循环查询的是字典的键
get("键") #存在返回字典中键对应的值,不存在返回None
dic["键"] # 存在返回字典中键对应的值,不存在报错
其他操作
keys -- 获取字典中所有的键 存放在一个高仿列表中
values -- 获取字典中所有的值 存放在一个高仿列表中
items -- 获取字典中所有的键和值 存放在一个高仿列表里的元组(元组第一个元素:键,第二元素:值)
解构
a = 10
b = 20
a,b = b,a
字典的嵌套
dic = {1001:["周杰伦","林俊杰"],
1002:{"汪峰":{"前妻1":["大烧饼"],"前妻2":["熊大","熊二"],"国际章":"肉丝"}},
1003:{"陈冠希":["阿娇","阿萨","张柏芝"]},
1004:{"韦小宝":[{"教主夫人":["教主"]},
{"阿珂":"刺客"},
{"双儿":"天地会"},
{"爱心觉罗建宁":"公主"},
{"独臂神尼":{"韦小宝师父":{"兰陵王":"隐身"},"花木兰":[
"唧唧复唧唧","木兰是战士",{"爸爸":["花和尚"]}]
}},
{"陈圆圆":"丈母娘"},{"穆建平":"小郡主"}]},
1005:{"常鑫":["大黑哥","大烧饼","吃大煎饼","肉夹馍","自行车","井盖",]}
}
print(dic)
print(dic[1004]["韦小宝"][0]["教主夫人"][0])
print(dic[1005]["常鑫"][-1])
print(dic[1002]["汪峰"]["前妻2"][-1])
print(dic[1004]["韦小宝"][4]["独臂神尼"]["韦小宝师父"]["兰陵王"])
print(dic[1004]["韦小宝"][4]["独臂神尼"]["花木兰"][2]["爸爸"][0])
# 查找的时候一层一层的通过键进行查找
# 键
1.小数据池
1.1代码块: 一个文件,一个函数,一个类,一个模块,终端中每一行
1.1.1 数字: -5 ~ 256
1.1.2 字符串: 乘法时总长度不能超过20
1.1.3 布尔值: 内容相同内存地址相同
1.2 小数据池:
1.2.1 数字: -5 ~ 256
1.2.2 字符串: 乘法时总长度不能超过20
1.2.3 布尔值: 内容相同内存地址相同
1.3 先执行代码块后执行小数据池
1.4 == is
1.4.1 == 判断等号两边值是否相等
1.4.2 is 判断两边的值内存地址是否相等
2.深浅拷贝
2.1 赋值:
多个变量名指向同一个内存地址
一个变量对其进行操作,其他变量查看时都变动
2.2 浅拷贝:
lst[1:10] -- 是浅拷贝
浅拷贝只拷贝第一层元素
修改第一层元素时,新开辟的不进行改变
2.3 深拷贝:
不可变的数据类型共用,可变的数据类型重新开辟一个空间
对源数据进行修改,深拷贝的内容不进行改变
# 浅拷贝=修改第一层元素不改变,其它改变.
# 深拷贝=修改任何位置,另外一个不改变.
3.集合
3. 集合
3.1 集合是没用值得字典
3.2 集合是无序,可变的
3.3 集合天然去重
3.4
增:add ,update
删:pop remove clear
改:先删后加
查: for循环
3.5 其他操作:
& 交集
| 并集
- 差集
^ 反交集
> 超集
< 子集
frozenset() 冻结集合
3.6 面试题:
list(set(要去去重的数据))
1.编码解码
# 编码:将文字转换成字节形式 encode
# 解码:将字节转换成文字形式 decode
2.基础数据类型
str:
首字母大写
每个单词首字母大写
大小写反转
居中 -- 填充
查找:find index
拼接
格式化: name.format
list:
排序(默认是升序) 降序sort(reverse=True)
反转
查找 index
统计 count
+ * 元素都是共用的
面试题:
tuple:
(1,)# 元组
(1) # 括号里数据本身
+ *
dict:
popitem
fromkeys("可迭代的键",共用的值) -- 坑
dict(key = 1,key2 =2)
set:
set() -- 空集合
set("alex") # 迭代添加
3.坑
列表删除 -- 从后向前删除
创建一个新的列表,删除旧的列表
字典删除 -- 循环的时候不能改变源数据的大小 (可以改变值)
创建一个新的字典,删除旧的字典
集合删除 -- 循环的时候不能改变源数据的大小
类型转换
list -- str join
str -- list split
文件操作
open -- 打开文件
file -- 文件路径
mode -- 操作文件的模式
encoding -- 文件的编码集
打开文件
操作文件
关闭文件
r,w,a (******)
r: 读文本
read() 全部读取
read(3) 看文件的操作方式 r/w/a 字符
readline 读取一行(自带换行符)
readlines() 一行一行读取存放在列表中
w:清空,写
open("xxx","w",encoding="utf-8") # 进行清空
write() 只能写字符串
a:追加
在文本的末尾进行写入
write()
rb,wb,ab(****)
rb:读字节
read() 全部读取
read(3) 看文件的操作方式 rb/wb/ab 字节
readline 读取一行(自带换行符)
readlines() 一行一行读取存放在列表中
wb:清空,写
open("xxx","wb") # 进行清空
write() 只能写字节
ab:追加
open("xxx","ab")
write() 只能写字节
r+,w+,a+ (r+)
r+:读写
错误的方式是写读
先读后写
w+:清空写,读
1.清空文件
2.读取内容(默认读取的是空)
3.移动光标
a+:追加写,读
1.先写后读
2.读取内容(默认读取的是空)
3.移动光标
# 注意点: (a,ab,a+)将光标移动到某个位置进行,写入的时候还是在文件的末尾
其他操作:
tell() 查看光标返回的是字节
seek() 移动光标
seek(0,0) 移动文件头部
seek(0,1) 当前位置
seek(0,2) 移动文件末尾
seek(3) # 按照字节进行计算 (计算方式根据编码计算)
with open("文件路径","操作模式",编码")as f:
操作文件
with open的好处:
1.可以同时打开多个文件
2.能够自动关闭文件
修改文件内容:
1.创建一个新的文件
2.将文件中的内容进行替换
3.替换后的内容写入新文件中
4.改变文件名
重点
路径:
绝对路径: 从磁盘根部进行查找
相对路径: ../返回上一级 --推荐使用
转义:
1."C:\\user\\ner"
2. r"C:\user\ner" -- 推荐使用
