python - 基础

注意点

1，符号尽量写空格，不然容易报警告
2，if,while,for后面必须有缩进，不然报错

1,打印输出和注释

# 单行注释
"""
多行注释
"""
print('hello')

变量求和

变量会自动判断类型，但是也可以自己指定，变量名后加:，不要有空格

num1 = 2

num2 = 3

num3: float = num1 + num2

str = "需要求得"

print("%s两个数的和%d" % (str, num3))

字符输入

print("输入第一个字符")
num1 = input()
print("输入第二个字符")
num2 = input()

num3 = num1 + num2

# 任何输入都会被当做字符串，所以是%s
print("两个字符串拼接的结果是:%s" % num3)

运算

取商 a//b
取模 a%b
幂 a**b a 的多少 b次方

类型转换

查看类型 type(变量名)
转 int ，也可以将字符串转int

num1 = "2"
num2 = int(num1)
num3 = float(num1)
str1 = str(num2)

判断语句

if,else 后面加:而不是{}
逻辑运算符使用 and，or，not

num1 = 1

num2 = 3

if num1 > num2:
    print("num1大")
    print("num1大")
else:
    print("num2大")
    print("num2大")

if,elif 多重判断

num1 = 1

num2 = 3

num3 = 5
if num1 > num2:
    print("num1大")
    print("num1大")
elif num1 > num3:
    print("num1大")
    print("num1大")
else:
    print("num1小")
    print("num1小")

循环语句

while

num1 = 1

while num1 < 100:
    print(num1)
    num1 = num1+1

for in,如果使用break,将不会执行else:如果使用continue会执行 else:

num1 = "hello"

for x in num1:
    print(x)
else:
    print("循环退出")

切片操作

截取字符串，列表，元组的一部分
格式：[起始:结束:步长]，左闭右开型，左边包括下标，右边下标的前一位。
步长是过几个元素区一次，默认为1.结束位置默认为后面全部的元素

num1 = "hello"
print(num1[0:4:2])
print(num1[0:])

字符串操作

1，是否存在子串
find,返回找到的索引位置，不存在返回-1
index,返回找到的索引位置，不存在报异常
最大最小位置可以省略

num1 = "hello"
index = num1.find("e", 0, len(num1))
print(num1[index:])

2，子串的个数 count

num1 = "hello"
count = num1.count("l")
print(count)

3,字符串的替换
将 l替换为 k，最多替换一次

num1 = "hello"
count = num1.count("l")
str1 = num1.replace("l", "k", 1)
print(str1)

4,字符串分割
用空格分割两次字符串

num1 = "hello hello hello hello hello "
str1 = num1.split(" ", 2)
print(str1)

5,字符串首字母大写

num1 = "hello hello hello hello hello "
str1 = num1.capitalize()
print(str1)

6,字符串每个单词首字母大写

num1 = "hello hello hello hello hello "
str1 = num1.title()
print(str1)

7，字符串是否以 h开头

num1 = "hello hello hello hello hello "
str1 = num1.startswith("h")
print(str1)

8，字符串是否以 o 结束

num1 = "hello hello hello hello hello"
str1 = num1.endswith("o")
print(str1)

9,字符串所有大写字母小写

num1 = "Hello hello hello hello hello"
str1 = num1.lower()
print(str1)

10,字符串所有大写字母大写

num1 = "Hello hello hello hello hello"
str1 = num1.upper()
print(str1)

11，ljust

返回⼀个原字符串左对⻬,并使⽤空格填充⾄⻓度 width 的新字符串

mystr.ljust(width)  
result:"hello    "

12，rjust

返回⼀个原字符串右对⻬,并使⽤空格填充⾄⻓度 width 的新字符串

mystr.rjust(width)  
result:"     hello"

13，center

返回⼀个原字符串居中,并使⽤空格填充⾄⻓度 width 的新字符串

mystr.center(width) 
result:"   hello    "

14,lstrip

删除 mystr 左边的空⽩字符
mystr.lstrip()

15,rstrip

删除 mystr 字符串末尾的空⽩字符

16,strip

删除mystr字符串两端的空⽩字符

17,rfind

类似于 find()函数，不过是从右边开始查找

18,rindex

类似于 index()，不过是从右边开始.

19,partition

把mystr以str分割成三部分,str前，str和str后

20,rpartition

类似于 partition()函数,不过是从右边开始.

21,splitlines

按照⾏分隔，返回⼀个包含各⾏作为元素的列表

num1 = "Hello\n hello\n hello\n hello hello"
str1 = num1.splitlines()
print(str1)

22,isalpha

如果 mystr 所有字符都是字⺟ 则返回 True,否则返回 False

23,isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.

24,isalnum

如果 mystr 所有字符都是字⺟或数字则返回 True,否则返回 False

25,isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.

26,join
列表num1将str加到每个元素的最后组成一个字符串

str = " "
num1 = ["Hello", "Hello", "Hello", "Hello", "Hello"]
str.join(num1)
print(str.join(num1))

列表list[]

和数组不同的地方在于，列表的元素可以是任意类型的

1,列表的遍历

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
for name in num1:
    print(name)

2,添加

append给列表添加一个元素

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
num1.append(2)
for name in num1:
    print(name)

extend给列表添加一个列表

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
num2 = [2, 3, 4]
num1.extend(num2)
for name in num1:
    print(name)

insert指定位置插入一个元素

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
num1.insert(0, 0)
for name in num1:
    print(name)

3,修改

指定位置修改

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
num1[0] = 2
for name in num1:
    print(name)

4，查找

存在 in，和不存在 not in

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
str = "Hello"
if str in num1:
    print("YES")

index 查找位置

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
index = num1.index("Hello")
print(index)

count查找元素个数

num1 = [1, "Hello", "Hello", "Hello", "Hello"]
count = num1.count("Hello")
print(count)

5，删除

del：根据下标进⾏删除 ,注意del写最前面

pop：删除最后⼀个元素

remove：根据元素的值进⾏删除

num1 = [1, "Hello", "Hello", "HelloHello", "Hello"]
del num1[0]
num1.pop()
num1.remove("Hello")
print(num1)

6,排序

正序sort，倒序reverse

num1 = [1, 2, 6, 3, 7]
num1.sort()
num1.reverse()
print(num1)

元组()

方法和属性和列表类似，但是初始化后只能访问元素不能修改

字典{}

1，基本使用

info = {'name': '张三', 'age': 12}
print(info['name'])

获取值(不知道是否存在,不存在返回 none)

info = {'name': '张三', 'age': 12}
print(info.get('name1'))

2,修改值

info = {'name': '张三', 'age': 12}
info['name'] = "李四"
print(info['name'])

3，添加值

如果 key不存在，就会增加一个，存在就修改 value

info = {'name': '张三', 'age': 12}
info['id'] = 1
print(info.get('id'))

4，删除key

info = {'name': '张三', 'age': 12}
del  info['name']
print(info.get('name'))

删除全部字典 del info,打印报错

清空字典 clear info,打印为空

5，字典 元素的个数

len(info)

6,返回所有 key

info = {'name': '张三', 'age': 12}
print(info.keys())

7,返回所有 values

info = {'name': '张三', 'age': 12}
print(info.values())

8,返回键值元组列表

info = {'name': '张三', 'age': 12}
print(info.items())

9,遍历键值对

info = {'name': '张三', 'age': 12}
for key, value in info.items():
    print(key, value)

运算符

运算符	Python 表达式	结果	描述	⽀持的数据类型
+	[1, 2]+[3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	'Hi!' * 4	['Hi!', 'Hi!','Hi!', 'Hi!']	复制	字符串、列表、元组
in	3 in (1, 2,3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in(1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典

python内置函数

字典是先比较键，再比较值

del有两种⽤法，⼀种是del加空格，另⼀种是del()

序号	⽅法	描述
1	cmp(item1, item2)	⽐较两个值
2	len(item)	计算容器中元素个数
3	max(item)	返回容器中元素最⼤值
4	min(item)	返回容器中元素最⼩值
5	del(item)	删除变量

函数

函数定义和调用

def fun1():
   print("这个函数")
   print("这个函数")

fun1()

带参数的函数的定义和调用

help(函数名)，打印函数内的注释

def text(a, b):
    """求和"""
    print("和为%d" % (a + b))

text(1, 2)
help(text)

函数返回值

可以用元组来接收多个函数的返回值

def text(a, b):
    """求和"""
    return a+b

result = text(1,2)
print(result)

def text(a, b):

    return a+b, a-b

a1, a2 = text(1,2)
print(a1, a2)

缺省参数

调⽤函数时，缺省参数的值如果没有传⼊，则被认为是形参的默认值

注意：带有默认值的参数⼀定要位于参数列表的最后⾯

def printinfo( name, age = 35 ):

不定⻓参数
有时可能需要⼀个函数能处理⽐当初声明时更多的参数。这些参数叫做不定
⻓参数，声明时不会命名。
基本语法如下：
def functionname([formal_args,] *args, **kwargs):

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；⽽加
**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

def fun(a,  b,  *args,  **kwargs):

fun(1,  2,  3,  4,  5,  m=6,    n=7,    p=8)

参数对应 
a   =   1 b =   2
args    =   (3, 4,  5)
kwargs: p   =   8 m =   6 n =   7

引用传参

Python中函数参数是引⽤传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量⾃身；⽽对于可变类型来说，函数体中的运算有可能会更改传⼊的参数变量。

可变类型与不可变类型

可变类型，值可以改变：指向的数据可以修改

列表 list 字典 dict

不可变类型，指向的数据不可修改

数值类型 int, long, bool, float 字符串 str
元组 tuple

局部变量和全局变量

局部变量定义在函数内

全局变量定义在函数外

在函数内使用可以使用全局变量，如果要修改不可变类型的全局变量，必需要用global修饰全局变量，如果是修改可变类型的全局变量，不需要用global 修饰全局变量

匿名函数,一般作为参数

⽤lambda关键词能创建⼩型匿名函数。这种函数得名于省略了⽤def声明函数的标准步骤。 lambda函数的语法只包含⼀个语句，参数个数任意，如下：

lambda [arg1 [,arg2,.....argn]]:expression

匿名函数作为参数传递

def text(a, b, opt):
    result = opt(a,b)
    return a+b, a-b,result
a1, a2, a3 = text(1,2,lambda x,y:x*y)

print(a1, a2, a3)

作为内置函数的参数

stus    =   [
    {"name":"zhangsan", "age":18},
    {"name":"lisi", "age":19},
    {"name":"wangwu",   "age":17}
]

stus.sort(key = lambda x:x['age'])

print(stus)