南柯33的Python学习笔记第（一）部分

Python基础

1.Python简介

1.1 Python是什么编程语言

从编程语言的几个方向来说

编译型和解释型
- 什么是编译型？什么是解释型？
  - 编译型：就是把源代码一下全部都编译成二进制文件（优点：执行效率高。缺点：开发效率较低）
  - 解释型：就是源代码从上到下一条一条交给计算机，计算机收到一条就执行一条（优点：开发效率高。缺点：执行效率较低）
- Python属于解释型
静态语言和动态语言
- 什么是静态语言？什么是动态语言？
  - 静态语言：创建变量时需声明变量的数据类型
  - 动态语言：创建变量时不需要声明变量的数据类型
- Python属于动态语言
强类型定义语言和弱类型定义语言
- 什么是强类型定义语言？什么是弱类型定义语言？
  - 强类型定义语言：如果一个变量指定了一个数据类型，那么如果不强制转换那它永远就都是这个数据类型了
  - 弱类型定义语言：一个变量可以赋予多个数据类型的值
- Python属于强类型定义语言

2.Python入门

2.1输出

#python2 写法
print "Hello World!"

#python3 写法
print("Hello World!")
#如果要输出带有换行的，那么就用三对引号
print("""
第一行
第二行
""")
#如果在执行时报错或者乱码（输出中文会）
#在py文件的头加入:

#-*- coding:utf-8 -*-

2.2变量

什么是变量？
- 首先变量有一个名字，然后它有一个值。这就是变量
  - v(变量名) = 1（值）
  - ```
  v = 1
```
- 补充：这里的v所指向的不是1这个值，而是这个值所存在的内存地址

变量的命名规则：

变量名由字母，数字，下划线组成
变量不能是数字开头

禁止使用Python里面的关键字和内置函数的名字

常见关键字（help("keywords")可以查看）

help("keywords")

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not
class               from                or
continue            global              pass

如果记不住还有一点就是在使用IDE的时候如果是Python关键字那么它会变颜色

要见名知意（如下：

name = "nanke" #这让别人知道名字是nanke
#而不是
a = "nanke"

变量名写法
- 驼峰体：OnePage
- 下划线法：one_page

2.3常量

常量就是一般不更改的变量，一般用大写来表示。如：
```
LANGUAGE_NAME = "Python"
```

2.4注释

单行注释
```
#print("Hello World!")
```
多行注释
```
"""
name = "nanke"
print(name)
"""
```

2.5基本数据类型

其实本不该在这里列举的，因为基本数据类型里面有好多好多的操作方法。在这里我就简单介绍一下什么是整形，什么是字符串，什么是布尔

整形
```
val = 123
```
字符串
```
val = "123"
```
布尔
```
val = True
val = False
```
这里，是引号包裹起来的都是字符串，不管里面是什么

然后，不是引号包裹起来的数字几乎都是整型了

布尔型就只有两个一个真一个假（True和False）

2.6输入

python2

name = raw_input("请输入你的名字:")

python3

name = input("请输入你的名字：")

注意：不管是Python2还是Python3里面name接收的值的数据类型都是字符串类型。下面来举个栗子
```
n1 = input("请输入一个数字:")
n2 = input("请输入一个数字:")
val = n1 + n2
print(val)
```
- 在这里我n1输入1 ，n2输入2。那么val的值会是什么呢？
- 可能初学者会认为是3，但实际上并不是。
- 它会输出12（注：这里的12依旧是字符串）
- 为什么是12呢？因为这是做的字符串加法
- 如果我想让它变成真正的1+2呢？如下
```
n1 = input("请输入一个数字:")
n2 = input("请输入一个数字:")
val = int(n1) + int(n2)
print(val)
```

2.7if else elif

if
- if 就是如果XX 那就XX
- 说人话就是如果条件满足就执行什么
- 比如
- if 你是男人：
  
  进男厕所
```
if gender == '男':
    print('进男厕所')
```
if else
- 如果理解了上一个，那么这个也就好理解了
- 如果是男人就进男厕所，否则进入女厕所
```
if gender == '男':
    print('进男厕所')
else:
    print('进女厕所')
```

if elif else

如果理解了前两个，这个就瞬间懂了

if gender == '男':
    print('进男厕所')
elif gender == '女':
    print('进女厕所')
else:
    print('进宠物医院吧')

3.运算符

3.1while循环

什么是循环？
- 循环就好像是在操场跑圈，一直围绕着操场跑。
- 当然，一个人也不能无止境的跑，那么肯定有停下来的条件。
- 那么我让它跑十圈就停下来
```
i = 1
while i <= 10:
    print('跑了'+str(i)+'圈')
    i = i + 1
"""
跑了1圈
跑了2圈
跑了3圈
跑了4圈
跑了5圈
跑了6圈
跑了7圈
跑了8圈
跑了9圈
跑了10圈
"""
```
break
- 如果在跑10圈的过程中，如果外面突然打雷下雨，那么是不是就得停下来了
- 那么我让它在第五圈的时候就不跑了
```
i = 1
while i <= 10:
    print('跑了'+str(i)+'圈')
    if i == 5:
        break
    i = i + 1
"""
跑了1圈
跑了2圈
跑了3圈
跑了4圈
跑了5圈
"""
```
- 这里他跑了五圈就停止了。
- 所以很明显break的作用就是退出这一整个循环

continue

如果假设我们跑的这十圈里面可以使用接力，一个人替一个人跑一圈
那么我在第五圈的时候使用接力

i = 1
while i <= 10:
    if i == 5:
        i = i + 1
        continue
    print('跑了'+str(i)+'圈')
    i = i + 1
"""
跑了1圈
跑了2圈
跑了3圈
跑了4圈
跑了6圈
跑了7圈
跑了8圈
跑了9圈
跑了10圈

"""

这里可以看出来continue的作用就是退出这一个循环

总结
- break
  - 就是结束整个循环
  - 如果执行到break，那么就跳出这个循环体
- continue
  - 就是结束这一次的循环
  - 如果执行到continue，并不会跳出整个循环，只是结束这个循环的这一次的循环

3.2格式化输出

name = 'nanke33'
msg = "今天是个好日子，%s好开心"%(name,)
print(msg)

结果是
- 今天是个好日子，nanke33好开心

%d和%i

n1 = 1
n2 = 2
msg = "%d+%i=%d"%(n1,n2,n1+n2,)
print(msg)

结果是
- 1+2=3
这里%d和%i都是数字

%%
```
print("80%%")
```
- 结果是
  - 80%
- 这里要使用百分号%就得多加一个百分号来转义，不然Python会以为一个百分号是一个占位符

3.3运算符

3.3.1 算术运算符

#  +
print(1+2)  #3
#  -
print(2-1)  #1
#  *
print(2*2)  #4
#  /  除 (python3)
print(10/4) #2.5
#  /  除 (python2)
print(10/4) #2
#  %  取模
print(9/2)  #1
#  **  n1**n2 n1的n2次方
print(3**2)  #9
#  //  取整数
print(10/4)  #2

3.3.2比较运算符

#由于是比较运算，所以只有是或不是，返回布尔值，真或假
n1 = 1
n2 = 2
#等于
print(n1 == n2)   #False
#不等于
print(n1 != n2)   #True
#大于
print(n1 > n2)    #False
#小于
print(n1 < n2)    #True
#大于等于
print(n1 >= n1)   #False
#小于等于
print(n1 <= n1)   #True

3.3.3赋值运算符

n1 = 1
n2 = 2
#  =
n3 = n1 + n2
#  += 
n1 += n2 # n1 = n1 + n2
#  -= 
n1 -= n2 # n1 = n1 - n2
#  *=
n1 *= n2 # n1 = n1 * n2
#  /=
n1 /= n2 # n1 = n1 / n2
#  %=
n1 %= n2 # n1 = n1 % n2
#  **=
n1 **= n2 # n1 = n1 ** n2
#  //=
n1 //= n2 # n1 = n1 // n2

3.3.4逻辑运算

and（与）
```
print(True and False) #False
```
or（或）
```
print(True or False) #True
```
not（非）
```
print(not True) #False
```

3.3.5成员运算

in
```
print('a' in 'abc')#True
```
not in
```
print('a' not in 'abc')#False
```

4.数据类型

4.1整形（int）

在Python2中有int 和 long
在Python3中只有int

在Python2中的/要显示小数

from __future__ import division 
value = 3/2
print(value)

4.2布尔型（bool）

True
False

4.2.1转换

#整形除了0为False，其余的都是True
val = bool(1)  #True
val = bool(0)  #False

#字符串除了空字符串为False，其余的都是True
val = bool("")  #False
val = bool("nanke")  #True

其余的数据类型除了空的是False,非空的都是True

4.3字符串（str）

4.3.1字符串相加

n1 = "1"
n2 = "2"
val = n1 + n2
print(val)
#结果是12

4.3.2字符串相乘

如果有学过其他语言的小伙伴打印n条Hello World！会用循环来。在Python中有个简单的方法就是字符串相乘

val = "Hello World!\n"
print(val*8)
#结果
#Hello World!
#Hello World!
#Hello World!
#Hello World!
#Hello World!
#Hello World!
#Hello World!
#Hello World!

4.3.3索引

字符串的索引其实很简单，就比如一个单词Hello，它的第一个是H第二个是e...类似的，找它第几个就是字符串的索引，使用方法：
```
val = "Hello"
print(val[1])
#结果e
```
- 这里有人问，为啥不是H而是e，不是第一个吗？
- 因为计算机里面是从0开始数数的，而不是1.
- 所以这里的val[1]就代表val这个变量的第二个单词啦

4.3.4切片

什么是切片？切片其实就是把一个单词切成你想要的。
如：Hello你只想要Hel怎么做呢？
```
val = "Hello"
print(val[0:3])
#结果
#Hel
```
- 这个时候可能又会问，0-3不是四个吗？为啥只有三个
- 这里我的理解是因为它的区间是半开半闭区间[0,3）

4.3.5步长

什么又是步长呢？
我们又拿Hello举栗子，如果我想要Hlo这要怎么办呢？
```
val = "Hello"
print(val[::2])
#结果
#Hlo
```
- 可能机智的你已经意识到了对于字符串变量[a🅱️c] a b 代表范围 c 代表步长
- 我们再举个栗子123456789
- 如果我要这里面的1 3 5 7怎么做呢
```
val = "123456789"
print(val[0:7:2])
#结果
#1357
```

4.3.6字符串常用方法

4.3.6.1全部大写

见名知意就是把字符串的小写全部转换成大写
```
val = "Hello"
print(val.upper())
#结果
#HELLO
```

4.3.6.2全部小写

val = "Hello"
print(val.lower())
#结果
#hello

4.3.6.3首字母大写

val = "hello"
print(val.capitalize())
#结果
#Hello

4.3.6.4大小写转换

这个就是大写换成小写，小写换成大写

val = "Hello"
print(val.swapcase())
#结果
#hELLO

4.3.6.5判断以什么开头

val = "Hello"
print(val.startswith('H')) #True
val = "Hello"
print(val.startswith('h')) #False
val = "Hello"
print(val.startswith('e')) #False

所以这个是区分大小写的

4.3.6.6判断以什么结尾

val = "Hello"
print(val.endswith('o')) #True
val = "Hello"
print(val.endswith('O')) #False
val = "Hello"
print(val.endswith('h')) #False

4.3.6.7统计出现的次数

拿Hello来说 l出现2次其余的都只出现过一次

val = "Hello"
print(val.count("l"))#2
print(val.count("H"))#1

4.3.6.8查找下标

如Hello H是第0个下标就是0

val = "Hello"
print(val.find("H"))#0

那么如果是l呢？

val = "Hello"
print(val.find("l"))#2

结果不应该是2 和 3吗?
- 因为这个函数的运行机制就是找到一个就不找了，所以就是2
那如果找一个这个字符串里面不存在的呢
```
val = "Hello"
print(val.find('a')) #-1
```
- 所以找不存在的就会返回-1给我们

4.3.6.9字符串替换

定义变量name = "nanke33" 我要把nanke33换成nanke2333怎么做呢？
```
name = "nanke33"
print(name.replace("33","2333"))#nanke2333
```

4.3.6.10去掉头尾两边的空格

val = " Hello World! "
print(val.strip())#Hello World

很明显不能去掉中间的额空格

4.3.6.11字符串分割

如果有这么一个name.age.gender要分割成name age gender怎么做呢

val = "name.age.gender"
print(val.split("."))#['name', 'age', 'gender']

是不是和我们想的输出结果不一样呢？
- 对的，这个分割之后是以列表的形式返回给我们
- 什么是列表呢？我们下面会说

4.3.6.12字符串格式化

val = "Hello {}"
new_val = val.format("World!")
print(new_val)#Hello World!

4.3.6.13is

isdigit()判断是不是阿拉伯数字

val = "nanke33"
print(val.isdigit())#False

isalnum()判断是不是数字和字母

val = "nanke33"
print(val.isalnum())#True

isalpha()判断是不是纯字母和汉字

val = "nanke33"
print(val.isalpha())#False

下面就是补充一点点了

len()获取长度
```
val = "nanke33"
print(len(val))#7
```

while循环打印一个字符串

val = "nanke33"
count = 0
while count < len(val):
    print(val[count])
    count += 1

for循环打印一个字符串

val = "nanke33"
for item in val:
    print(item)

4.4列表（list）

4.4.1什么是列表

在之前我们已经看到过列表了，['name','age','gender']
类似这样子的就是列表，当然列表不仅仅能存字符串，它还能存别的数据类型，还可以列表里面嵌套列表

4.4.2列表的索引

如果理解了前面字符串索引的意思，那么列表的索引也就明白了
```
lst = ['name','age','gender']
print(lst[0])#name
```

你以为这样就结束了？不不不还有呢，我还能改lst[0]的值

lst = ['name','age','gender']
lst[0] = "姓名"
print(lst)#['姓名', 'age', 'gender']

4.4.3列表的切片

其实列表的切片与字符串的切片几乎都差不多

lst = ['nanke1', 'nanke2', 'nanke3', 'nanke4', 'nanke5', 'nanke6']
print(lst[0:4])#['nanke1', 'nanke2', 'nanke3', 'nanke4']
print(lst[1:5:2])#['nanke2', 'nanke4']

4.4.4列表的常用函数

append()

lst = [1, 2, 3]
lst.append(4)
print(lst)#[1, 2, 3, 4]

insert()

lst = [1, 2, 3]
lst.insert(1, 4)#第一个参数是在下标是1的地方插入第二个参数，原来的往后移动
print(lst)#[1, 4, 2, 3]

extend()

lst = [1, 2, 3]
lst.extend([4, 5])#将一个课迭代对象里面的东西迭代进lst
print(lst)#[1, 2, 3, 4, 5]

pop()

lst = [1, 2, 3]
lst.pop()
print(lst)#[1, 2]

lst = [1, 2, 3]
lst.pop(1) #pop里面可以传参数，参数就是列表的下标,如果不传就默认删除最后一个
print(lst)#[1, 3]

remove()

lst = [1, 2, 3]
lst.remove(2)#删除这个值是这个参数的元素
print(lst)#[1, 3]

clear()

lst = [1, 2, 3]
lst.clear()#清空列表里面的所有东西
print(lst)#[]

reverse()

lst = [1, 2, 3]
lst.reverse()#将列表反转
print(lst)#[3, 2, 1]

sort()

lst = [2, 1, 3]
lst.sort()#将列表内的数字排序,默认从小到大
print(lst)#[1, 2, 3]

lst = [2, 1, 3]
lst.sort(reverse=True)#加了这个参数就是从大到小排序了
print(lst)#[3, 2, 1]

count()

lst = [1, 2, 3]
print(lst.count(2))#统计列表中2的出现次数#1

len()
- 当然列表也是可以获取它的长度的
```
lst = [1, 2, 3]
print(len(lst))#3
```

4.5.元组（tuple）

什么是元组呢？
- (1, 2, 3)长这样的就是元组
元组和列表有什么区别呢？
- 列表可以更改，而元组不可以更改，只能查看

4.6.range

range实际上可以理解为范围
```
print(range(6))#range(0, 6)
```

什么？不理解？

lst = list(range(6))
print(lst)#[0, 1, 2, 3, 4, 5]

理解了吧，当然还有

lst = list(range(0,6,2))
print(lst)#[0, 2, 4]

4.7字典（dict）

什么是字典？
- 这样的就是字典
```
dic = {'k1':'v1', 'k2':'v2'}
print(dic['k1'])#v1
```
- 怎么样好理解吧，要是不理解就自己细品，哈哈哈
字典有什么用？
- 字典其实就是查看里面的数据的
- 那么有人会说列表，元组都可以啊。
- 列表元组查元素是从开始到结束一个一个的找的。
- 而字典就是根据键直接找到值,这样就会很快很快

4.8.集合（set）

什么是集合？
- 长上面那样的就是集合
- 这个怎么这么眼熟？集合不也是这个吗？
- 虽然都是大括号，其实两者是有区别的。
- 集合是一个一个的元素，而字典是key和value成对出现的
集合中的元素是不能重复的，要都是可以哈希的，且会自己按顺序排列
```
set1 = {2, 3, 3, 1}
print(set1)#{1, 2, 3}
```

add()

set1 = {1, 2, 3, 4, 5}
set1.add(6)
print(set1)#{1, 2, 3, 4, 5, 6}

pop()
```
set1 = {1, 2, 3, 4, 5}
set1.pop()#随机删除一个
print(set1)#{2, 3, 4, 5}
```
- 我看别人的是随机删除一个
- 这里是带返回值的，返回删除了的那个
- 在我使用数字的时候，默认就是删除的最小的那个
- 但是在用字符串的时候就不一定了，就是随机删除了，这里大家注意一下