-
is
is 判断两个标识符是否引用同一个对象，x is y 类似 id(x)==id(y)
is not 判断两个标识符是否引用不同对象，x is not y 类似 id(x)!=id(y)
is 和 == 区别：
is 判断两个标识符是否引用同一个对象
== 判断引用变量的值是否相等
针对None进行比较时，建议使用is
- for & while
names = ['Naruto', 'Luffy', 'Conan', 'Sasuke']
for name in names:
print(name)
else:
print("没有通过break退出循环，循环结束后，会执行的代码")
index = 0
while index < len(names):
print(names[index])
index += 1
- 函数
- 多个返回值
# 多个返回值,其实就是一个tuple
def move(x, y, step, angle=0):
# 一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标
# angle=0 表示默认参数
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
# 可以使用多个变量一次接收所有返回值
x, y = move(100, 100, 60, math.pi / 6)
print(x, y) # 151.96152422706632 70.0
# 可以用一个元组接收多个返回值
z = move(100, 100, 60, math.pi / 6)
print(z) # (151.96152422706632, 70.0)
交换两个变量的值：
def change(a, b):
# 利用元组
a, b = b, a
return a, b
- 缺省参数
# 缺省参数必须指向不变对象，缺省参数放在最后
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name, ' gender:', gender, ' age:', age, ' city:', city)
enroll('xiaolan', 'A', 7, 'shenzhen')
enroll('xiaobai', 'F')
enroll('xiaohei', 'B', 5)
enroll('xiaofen', 'C', city='shanghai') # 不是按顺序输入，需要写上参数名
- 多值参数（知道）
'''
参数名前增加一个* 可以接收元组,命名规则：*args
参数名前增加两个* 可以接收字典,命名规则：**kwargs
'''
def calc(*args):
sum = 0
for n in args:
sum = sum + n * n
return sum
print(calc(1, 2, 3))
# *nums表示把nums这个list的所有元素作为可变参数传进去
nums = [1, 2, 3]
print(calc(*nums))
print('=' * 50)
def person(name, age, **kwargs):
print('name:', name, 'age:', age, 'other:', kwargs)
person('Michael', 30) # name: Michael age: 30 other: {}
person('Bob', 35, city='Beijing') # name: Bob age: 35 other: {'city': 'Beijing'}
person('Adam', 45, gender='M', job='Engineer') # name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra) # name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
print('=' * 50)
# 如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数
def person3(name, age, *, city, job):
print(name, age, city, job)
# 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：
person3('Jack', 24, city='Beijing', job='Engineer')
# 参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
- 递归函数
# n! = 1 x 2 x 3 x ... x n
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
print(fact(5))
尾递归
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。
编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
def fact_iter(num, result=1):
if num == 1:
return result
return fact_iter(num - 1, num * result)
fact_iter(5)
- 私有函数
# _xxx和__xxx这样的函数或变量就是非公开的（private）,不应该被直接引用
def __private__(name):
return 'Hello, %s' % name
print(__private__("xiaoli"))
# 查看对象内的所有属性和方法
print(list.__dir__())
注：
在函数内部针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响外部变量的引用;
如果传递的参数是可变类型，在函数内部，使用方法修改变量内容，同样会影响外部变量。
L = ['Hello', 'World', 'IBM', 'Apple']
list = [s.lower() for s in L]
print(list) # ['hello', 'world', 'ibm', 'apple']
- list
# list里面的元素的数据类型也可以不同
list = ["hahah", 1, ['a','d'], True]
name_list = ["鸣人", "佐助", "小樱"]
print(name_list)
for name in name_list:
print(name)
n = 0
while n < len(name_list):
print(name_list[n])
n += 1
# list长度
print("列表中包含%d个元素" % len(name_list)) # 3
# list中某个元素有几个
count = name_list.count("鸣人")
# 往list中追加元素到末尾
name_list.append("卡卡西")
# 元素插入到指定的位置
name_list.insert(1, "佐井")
# 将一个列表中元素增加到另一个列表中
list1 = ["猪八戒", "孙悟空"]
name_list.extend(list1)
# 把某个元素替换成别的元素
name_list[0] = "漩涡鸣人"
# 获取元素下标,如果元素不在列表中，会报错
print(name_list.index("小樱"))
# 删除list末尾的元素
name_list.pop()
# 删除指定位置的元素
name_list.pop(1)
# 删除指定元素，数据不存在会报错
name_list.remove("猪八戒")
print(name_list)
# 清空列表中的元素
name_list.clear()
# 扩展：删除列表中指定下标元素 可以用del
list2 = ["aaa", "bbb", "ccc"]
del list2[0]
# del也可以将变量从内存中删除
# a = "aaa"
# del a
# 排序
list3 = ["zhangsan", "lisi", "wangwu"]
list3.sort() # 升序排列
list3.sort(reverse=True) # 降序排列
# 逆序（反转）
list3.reverse()
# 列表相加 +=相当于调用extend()方法
list1 = [1, 2, 3]
list2 = [4, 5]
list3 = list1 + list2
print(list3) # [1, 2, 3, 4, 5]
print(list3 * 2)
- tuple
my_info_tuple = ("路飞", 17, "船长")
print(my_info_tuple[1])
print(my_info_tuple.index("船长"))
# 某个元素在tuple中出现的次数
count = my_info_tuple.count("路飞"))
len = len(my_info_tuple))
for name in my_info_tuple:
print(name)
# 元组和列表的转换
list1 = ["猪八戒", "孙悟空", "沙和尚"]
tuple1 = ("柯南", "路飞", "鸣人")
# 元组转列表
list2 = list(tuple1)
# 列表转元组
tuple2 = tuple(list1)
# 只有一个元素的元组
tuple = (1,)
# 元组相加
tuple1 = (1, 2, 3)
tuple2 = (4, 5)
tuple3 = tuple1 + tuple2
- dictionary
student_dic = {"name": "小明", "age": 10, "score": 67.2}
# 取值 key不存在返回None
print(student_dic.get("nnn"))
# key不存在返回指定value
print(student_dic.get("nnn", -1))
# student_dic["key"],key不存在会报错,in判断的是key
if "nnn" in student_dic:
print(student_dic["nnn"])
else:
print("key不存在")
# 删除元素
student_dic.pop("age")
# 增加、修改元素
student_dic["height"] = 155
# 统计键值对数量
len = len(student_dic))
# 合并字典, 如果被合并的字典中包含已经存在的键值对，会覆盖原有键值对
dic1 = {"key1": "value1"}
dic2 = {"key2": "value2", "key1": "value3"}
dic1.update(dic2)
# 清空字典
dic1.clear()
# 循环遍历
for key in student_dic.keys():
print("key =", key)
for value in student_dic.values():
print("value =", value)
for key, value in student_dic.items():
print("key =", key, ", value =", value)
- String
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
str = 'Runoob'
print(str[0:-1]) # 下标为0的字符到倒数第二个字符
print(str[0]) # 下标为0的字符
print(str[2:4]) # 下标为2的字符到下标为4之前的字符
print(str[2:]) # 下标2开始的后的所有字符
print(str * 2) # 输出字符串两次
print(str + "TEST") # 连接字符串
print(str[-1:]) # -1表示最后一个字符
# 使用反斜杠()转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串
print('Ru\noob')
print(r'Ru\noob')
string = "asdfogoakmold"
# 字符串string长度
len = len(string))
# string中字符串"o"的个数
count = string.count("o")
# 字符串string中是否包含字符串“a”,返回string中第一个“a”所在下标,不存在返回-1
index = string.find("a")
index = string.rfind("a") # 从右往左查找
# 返回字符串string中字符串“a“所在下标，不存在报异常
index = string.index("a")
index = string.rindex("a") # 从右往左查找
# 将string中的"old"用"new"替换,原字符串不会改变，返回新的字符串
string.replace("old", "new")
string.replace("old", "new", 1) # 只替换第一个"old"字符串
# 判断字符串string是否以"a"开头
string.startswith("a")
# 判断字符串string是否以"s"结尾
string.endswith("s")
# 将字符串string转为小写
string.lower()
# 将字符串string转为大写
string.upper()
# 去掉字符串左边空格
string.lstrip()
# 去掉字符串右边空格
string.rstrip()
# 去掉字符串两边空格
string.strip()
width = 20
# 返回原字符串左对齐，并且使用空格填充至长度的width的新字符串
string.ljust(width)
# 返回原字符串右对齐，并且使用空格填充至长度的width的新字符串
string.rjust(width)
# 返回原字符串居中，并且使用空格填充至长度的width的新字符串
string.center(width)
# 将字符串按照某个字符串进行分割,split()方法不传任何参数时,则按照任意空白字符分割
string = "er ewe dsdsf fdsfs"
string.split(" ") # ['er', 'ewe', 'dsdsf', 'fdsfs']
# 将字符串string以"str"分割为三部分，str前、str、str后，以第一个"str"为准
string.partition("str")
string.rpartition("str") # 从右边起
# 字符串按 “\n”切割
string.splitlines()
# 字符串中是否都是数字,都不能判断小数
string.isdecimal() # 全角数字,尽量使用这个方法
string.isdigit() # 全角数字、"(1)"、\u00b2(unicode字符串)
string.isnumeric() # 全角数字、汉字数字
# 字符串中是否都是字母
string.isalpha()
# 字符串中是否只有数字和字母
string.isalnum()
# 字符串中只包含空格
string.isspace()
# string每一个字符后插入字符串sss,构造新的字符串
sss = "xxx"
sss.join(string) # axxxbxxxcxxx1xxx2xxx3
# 字符串的切片，切片同样适用于list和tuple
# str[索引:索引:步长]
str = "0123456789"
str1 = str[0:5] # 01234
# 从下标为0的字符开始，到下标为8的字符之前（左闭右开）,每隔三个字符取一个
str2 = str[0:8:3] # 036
# -1表示从右向左切
print(str[-1::-1]) # 9876543210
print(str[::-1]) # 9876543210
-
变量
在开发时，应该把模块中的全局变量定义在所有函数的上方
全局变量名应加 g_ 或 gl_ 前缀
gl_name = "唐僧"
# 函数内部修改全局变量
def test():
# global关键字表示后面的变量是一个全局变量，再使用赋值语句时，就不会创建局部变量
global gl_name
gl_name = "悟空"
print(gl_name)
- 三元运算符
# a b c最大值
max = a if a > b else b
max = max if max > c else c
-
range()
range() 生成一个自然数序列
通过range()可以创建一个执行指定次数的for循环
# 生成[0,1,2,3,4]
range(0,5)
# 执行10次
for i in range(10):
print(i)
网友评论