python 基础

文件名：

python 的文件名后缀可以是任意的，但最好还是.py ，因为在导入模块的时候，如果文件不是 .py的话会导入错误。

运行：

• 所有系统：python hello.py
• 在Linux中可以使用 ./hello.py 来执行python文件，但需要在 文件首行加入 #!/usr/bin/bin/env python 来指明python解析器的位置。

编码：

• python 3 无需关注编码
• python 2 默认是使用ASCII 码进行读取，则不能出现中文，所以如果用中文的话，得在文件开头加入 # -*- coding:utf8 -*-

注释：

• 单行注释以 # 开头
• 多行注释用三个单引号 ''' 或者三个双引号 """

命名规则（标识符）：

只能包含字母、数字和下划线

• 第一个字符不能是数字
• 不能是关键字，可通过  >>> import keyword   >>> keyword.kwlist 获取所有的关键字
• 不要跟python 内置的东西重复，如函数名，例如python有内置函数sum([1,2]), 如果定义了变量sum，就会覆盖自带的求和函数

命名规范：

1. 模块：尽量使用小写命名，首字母保持小写，尽量不要用下划线(除非多个单词，且数量不多的情况)
2. 类名：使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头
3. 函数：一律小写，如有多个单词，用下划线隔开
4. 变量：尽量小写, 如有多个单词，用下划线隔开
5. 常量：使用以下划线分隔的大写命名

条件语句：

if 条件 :
    代码块...(同缩进)
elif 条件 :
    代码块
else:
    pass
# pass表示跳过，不执行

循环语句：

while 条件 :
    代码块（continue：终结本次循环 break：跳出整个循环）
else:
    #while条件不成立时执行这里



for 变量名 in  字符/列表等:
    代码块

获取一个范围内的数字 

m = range(10)
print(m)  # range(0, 10) 只是声明，还不会分配内存去创建1到10 ，等需要使用的时候就会去创建

n = range(2, 10)  # 指定开始值
for n1 in n:
    print(n1)

o = range(3, 10, 2)  # 指定步长为2
for o1 in o:
    print(o1)

 

基本数据类型：（type(a) 可以查看a的数据类型）

1. 字符串：(str)

•  ‘hello’ ，"hello" ,  '''hello''' """hello"""  这几种定义都是合法的
• 加法： 字符串拼接。如：a="hello"  b="world"  c=a+b,则c为："hello world"
• 乘法：字符串倍数出现，如：a="abc" ,b=a*3, 则b为："abcabcabc"
• in / not in : 判断一个字符串 在/不在 另一个字符串里面  a="abc"  b="b"  则 b in a 结果为true  
• 字符串一旦创建就不可修改，修改拼接等操作都会创建新的字符串
• 字符串不能跟数字直接相加，需要将数字转为字符串先  str(2)

# 在指定范围内查找某个字符串,找不到返回-1，index()是查找，但找不到会报错
d = "i am python i am cpython"
d1 = d.find("th")
d2 = d.find("am", 5, 12)
print(d1, d2)  # 7 -1

# 替换字符串，第三参数表示替换的个数
f = "i am pthon,pthon easy"
f1 = f.replace("thon", "ython", 1)
print(f1)  # i am python,pthon easy

# 分割字符串，第二个参数表示分隔的次数，partition()也可分隔，但不能指定次数
g = "abc#efg#hijk#lmn"
g1 = g.split("#", 2)
print(g1)  # ['abc', 'efg', 'hijk#lmn']

# 将字符串中的每一个元素按照指定分隔符进行拼接
h = "你是风儿我是沙"
h1 = "*".join(h)
print(h1)  # 你*是*风*儿*我*是*沙

# 从两端(必须从两端的第一个字符就得匹配到)删除指定字符串,默认空格
j = "abcceabc "
j1 = j.strip()
j2 = j.strip("cc")
j2 = j.strip("abc")
j3 = j.rstrip(" acb")
j4 = j.lstrip("bca")
print(j1, j2, j3, j4)  # abcceabc eabc  abcce eabc

# 大小写转换
i = "I want to travel"
i1 = i.upper()
i2 = i.lower()
print(i1, i2)

# 字符串截取
k = "abcefghijklmn"
k1 = k[2]
k2 = k[2:6]
k3 = k[4:-1]
print(k1, k2, k3)  # c cefg fghijklm

# 判断字符串是否以指定字符开始或结束
b = "good good study"
b1 = b.startswith("goo")
b2 = b.endswith("dys")
print(b1, b2)  # True False

# 将字符串中的占位符替换成指定的值
e = "i am {name} ,age {age}"
ee = "i am {0}, age {1}"
e1 = e.format(name='xiaoming', age=18)
ee1 = ee.format("python", "19")
print(e1, ee1)  # i am xiaoming ,age 18 i am python, age 19

 

2. 数字：（int   注：python3数字类型都为int ，在python2 中存在着 int 和 long）

• a=39/8  a为：4.875    b=39%8   b为：7   c=39//8 c为：4
• a=2  b=3  c=a**b   则成为：8     **跟Java中的^相似，表示幂
• a="12"  b=int(a)  将字符串转为数字
• a="a"  b=int(a,base=16)  使用16进制读取a,并将a 转为10进制

3. 布尔值：（bool）

• True / False  首字母大写
• 0、''、[]、()、{}、None 都是对应False，可用 bool(arg) 内置函数进行测试

4. 列表：（list）

• 有序，元素类型任意，使用链表实现
• li=[1,2,3,4]   li[-1]=4   索引为-1时表示读取最后一个元素

# 添加元素
li2 = [2, "d"]
li2.append([3, 4])  # 追加元素
print(li2)  # [2, 'd', [3, 4]]

li3 = ["a", "c", "d"]
li3.insert(1, "b")  # 在指定位置插入元素
print(li3)  # ['a', 'b', 'c', 'd']

li1 = [1, 23, 4, 5]
li1.extend("23")  # 要求参数是可迭代的，因为该方法是通过遍历参数，然后将值append 到列表中
print(li1)  # [1, 23, 4, 5, '2', '3']

# 删除元素
li4 = [2, 3, 1, 2, 6]
li4.pop()  # 根据索引删除元素，默认是最后一个
print(li4)
li4.pop(3)
print(li4)

li5 = ["a", "b", [1, 2], "c"]
li5.remove([1, 2])  # 根据值删除元素
# li5.remove([1,2,3]) # 值不存在时会报错
print(li5)

li6 = ["a", "b", [1, 2], "c", 1, 2, 4, 0]
del li6[2]
print(li6)
del li6[2:-1]  # ['a', 'b', 0] -1应该是代表索引的最大值，而删除的时候>=  <
print(li6)

li7 = [1, 2, 3]
li7.clear()
print(li7)

list

# 修改
li8 = [1, 4, 3, 4]
li8[1] = 2
print(li8)

# 其他
li9 = [1, 2, 4, 5, 2, 2]
i = li9.index(2, 2, 5)  # 获取某个元素的索引,找不到会报错。参数一：要查找的值，参数二：开始查找的索引 参数3： 结束查找的索引
print(i)

li10 = [1, 4, 7, 3, 3, 6]
li10.sort()
print(li10)
li10.sort(reverse=True)
print(li10)

li11 = ["a", "b", "c"]
li_copy = li11.copy()
print(li_copy)  # 浅拷贝

li12 = ["a", "b", "c"]
li12.reverse()
print(li12)

5. 元祖：（tuple）

• 有序，元素类型任意，一级元素不可修改、删除、增加

tu = (1, "a", [1, 2, ("python", "java")], (3, 5))
tu[2].append(3)  # 修改非一级元素
print(tu)

tu1 = tu[2][2][0]  # 获取元祖中的某个元素
print(tu1)

tu2 = tu[1:3]  # 切片获取元素
print(tu2)

6. 字典：（dict）

• 无序，key 可以是字符串、数字、列表、布尔值类型。（布尔值的True 相当于1，则如果字典中已有以1为key的键值对，则True不会显示）
• key通过hash存储，所以key是唯一的，而value是任意的

dic = {"a": 12,
       "b": "python",
       33: [1, 2, 3],
       "c": {"k1": "v1"},
       "d": 3
       }

dict1 = dict.fromkeys(["a", "b", "c"], [1, 2])  # 根据key集合创建同value的字典
print(dict1)

#获取
v1 = dic[33]  # key 不存在时报错
print(v1)
v2 = dic.get("d", "default")  # key 不存在时返回None ,可以通过第二个参数指定默认值
print(v2)

#删除
v3 = dic.pop("a")  # 删除指定的key并返回删除的值
print(v3)
v4 = dic.pop("aa", "no exist")  # 找不到指定key 的时候，可指定返回的默认值
print(v4)

k, v = dic.popitem()  # 删除某个元素 ,并返回整个key-value
print(k, v)

# 添加
v5=dic.setdefault("b","java")  # 已存在，不设置，获取当前key对应的值
print(dic,v5)
v6=dic.setdefault("hehe",99) #不存在，设置，获取当前key对应的值
print(dic,v6)

#修改
dic.update(b="java")
print(dic)
dic.update({"b":"c++"})
print(dic)

#遍历
for k in dic.keys():
       print(k)

for v in dic.values():
       print(v)

for k,v in dic.items():
       print(k,v)

7. 集合：（set） 

• 无序，元素不可重复，元素是不可变的（数字，元祖，字符串，布尔）
• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

# 创建
s = set([3, "a", True, (1, 2)])  # 参数必须能遍历
print(s)

s_frozen = frozenset("python")  # 创建不可变集合
print(s_frozen)
# s_frozen.add("d") 报错

# 添加
s.add("python")
print(s)

# 修改
s.update([1, 2, 3, 4])  # 这是一个并集操作，想一次性添加多个值可使用该方法
print("修改", s)

# 删除
s.pop()  # 随机删
print(s)

s.remove(3)  # 删除指定值，不存在报错
print(s)

s.discard("nothing")  # 删除指定值，不存在不报错
print(s)

# 集合运算
s1 = {"a", "b", "e", "f"}
s2 = {"b", "f", "g"}

s_intersection = s1.intersection(s2)  # 交集
print(s_intersection)

s_union = s1.union(s2)  # 并集  s1+s2
print(s_union)

s_difference = s1.difference(s2)  # 差集  s1-s2
print(s_difference)  # {'a', 'e'}

s_symmetric_difference = s1.symmetric_difference(s2)  # 交叉补集，即两个集合的并集减去两个集合的交集
print(s_symmetric_difference)  # {'g', 'e', 'a'}

s1.difference_update(s2)  # 求完差集后将差集赋值给s1
print(s1)  # {'e', 'a'}

s3 = {1, 2, 3, 4}
s4 = {5, 6, 1, 2, 3, 4}

v1 = s3.isdisjoint(s4)  # 是否没有交集
print(v1)

v2 = s3.issubset(s4)  # 是否是子集 同理，issuperset()是判断是否是父集
print(v2)

运算符：

• 逻辑运算符：

and：同Java的&& ，表示与 ； or ： 同Java的 || 表示或 ；  not ： 同Java的 ! 表示非

• 身份运算符

is：判断两个标识符是不是引用自一个对象 ； is not : 跟 is 想反

a is b 类似于 id(a) == id(b)

注： id() 函数用于获取对象内存地址。

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

字符串格式化：

name = 'zhangsan'
age = 20
money = 123455.956

# %s 能接收所有类型， %d 只能接收数字(存入浮点数会变成整数)  %f 接收浮点数,默认保存6位
s1 = "i am %s age %d money %f list %s" % (name, age, money, ['k1', 1])
print(s1)

# 浮点数格式化
s2 = "my money have %.2f" % money
print(s2)

# 百分比
s3 = "percent is %.2f%%" % 99.876
print(s3)

# 字典匹配
s4 = "i am %(name)s" % {'name': name}
print(s4)

#######################    str format     #####################
person1 = {"name": "zhangsan", "age": 18}
person2 = ["lisi", 20]

s5 = "i am {} age {} percent{:%}".format(name, age, 45.32)
print(s5)

s6 = "i age {1} name {0} name {0} again ".format(name, age)
print(s6)

s7 = "i name {name} age {name}".format(**person1)  # 两个*表示用字典解析
print(s7)

s8 = "i name {:s} age {:d}".format(*person2)  # 一个*表示用列表解析
print(s8)