python零基础到进阶分享最详学习笔记，学习方法值得参考！
PyCharm下载安装
其实在安装完Python后就可以进行Python编程了，直接命令行输入python3， 就可以使用自带的IDLE进行开发了；又或者直接用Sublime Text或NotePad++ 这类代码查看工具直接编写代码，然后保存成后缀为.py的文件，然后python3 执行这个py文件就可以了。
虽然可以，但是挺不方便的，比如缩进问题，Python通过缩进来表示代码块， 代码一多，某一行没有正确的使用缩进，结果可能与你预期的相差甚远。 智能提示，方便的依赖库管理等，这两个就不用说了吧，具体的还得你自己体会。
官网下载：www.jetbrains.com/pycharm/dow… 下载Professional版本，傻瓜式安装，打开后会弹出注册页面， 勾选License server，在License server address输入注册服务器， 网上搜很多，然后就可以愉快的进行py开发了。
软件的基本使用也非常简单，Jetbrains的IDE都是差不多的~ 有一点要注意的地方是，如果你想切换项目依赖的Python版本号的话： 打开设置(Preference或settings)，修改即可：
4.基本常识
1) 导包
有时项目中需要引入其他模块或者模块中的某个函数，需要用到import和 from...import，用法示例如下：
import sys # 导入整个模块 from sys import argv # 导入模块中的需要用到的部分 from urllib.error import URLError, HTTPError # 多个的时候可以用逗号隔开 from sys import * # 导出模块中的所有 # 另外还可以使用as关键字为模块设置别名，比如 import sys as s # 调用的时候直接s.argv 这样就可以了。
2) 关键字与标识符命名规则
在对变量或者方法名这些标识符进行命名的时候，需要注意，不能够 与Python中的关键字相同，通过keyword.kwlist可以查询所有的关键字： 需要import keyword模块哦~
除了不能与与关键字相同外，标识符的命名规则： 由字母，数字和下划线组成，且首字符必须为字母或下划线， Python对大小写敏感；关于命名规范的问题，没有什么 强制规定，整个项目保持统一就好，附上网上找的一个命名规则：
1.项目名：首字母大写，其余小写，用下划线增加可读性，如：Ui_test；
2.包名与模块名：全部小写字母；
3.类名：首字母大写，其余小写，多个单词驼峰命名法；
4.方法(函数)名：全部小写，多个单词用下划线分隔；
5.参数名：小写单词，如果与关键词冲突，参数名前加上下划线，比如_print;
6.变量：小写，多个单词用下划线分隔；
7.常量：全部大写，多个单词用下划线分隔；
3) 注释
Python 使用 # 来进行 单行注释，多行注释 的话使用三引号，比如：
''' 这是 Python的 多行注释 '''
4) print打印输出与input输入函数
学习一门新的编程语言，第一个程序基本都是打印Hello world， 把结果打印到屏幕上，是验证代码执行结果的最直观体现，所以 有必要先学一波 print 和 input 的用法！
print():
1.可以输出各种乱七八糟类型的数据直接转成字符串打印输出；
2.print默认会换行，如果不换行可以: print(xxx, end = "")
3.支持 格式化输出，和C中的printf用法类似，逗号分隔前后改成**%**：
input():
从键盘读入一个字符串，并自动忽略换行符，所有形式的输入按字符串处理。 可以在括号里写一些输入的提示信息，比如: input("请输入一个字符串：")
输出结果：
5) help函数
这个就不用说了，很多编程语言都有的，可以用来查看某个 内置函数(BIF) 的相关用法的，比如help(print)，会输出这样的结果：
6) dir函数
查看对象内所有属性与方法，只需要把要查询的对象添加到括号中即可， 比如定义一个类，然后用dir可以获取所有的属性与方法：
部分输出结果：
7) 查看所有内置函数(BIF)
执行：print(dir(sys.modules['builtins'])) 可以打印出所有的内置函数。
8) 多个语句一行与一个语句多行
如果你想把多个语句写到一行，可以使用**；** (分号)分隔； 有时语句可能太长，你可以使用**\** (反斜杠)来衔接， 而在**[] , {} , ()**里的不需要使用反斜杠来衔接。
5.数据类型
1) 变量
Python3里定义一个变量非常简单粗暴，直接一个 变量名 = 初值 赋值时就决定了变量的数据类型，变量名引用了数值的同时也引用 它的类型，如果不理解的话，看下例子就知道了，**
type**可以查看 变量的数据类型(另外还要注意Python对大小写敏感，区分大小写！)：
输出结果：
另外Python中**支持多个变量赋值**，以下这两种赋值写法是正确的：
a = b = c = 1 a,b,c = 1,2,"Python"
对了，你还可以使用**del关键字删除对象的引用**，但删除后再调用 变量是会报错的！
输出结果：
2) 数字(Mumber)
Python3中支持四种数字类型：int，float，complex(复数)
注：Python3中 int 不区分整形与长整形，整数的长度不受限制， 所以很容易进行大数计算。而除了十进制外的进制表示如下： 二进制0b，八进制0o，十六进制0x 开头。
Python支持复数直接表示法，就是**(a+bj)的形式，complex类的实例， 可以直接运算，比如：a = 1 + 2j + 3 * 4j，输出a，结果是：(1+14j)** 实数+虚数，除了a+bj，还可以用**
complex(a,b)
表示，两个都是 浮点型，可以调用.real获得实部，.imag** 获得虚部，abs()求复数 的模(√(a^2 + b^2))。
数字类型转换：(Python文档中，方括号[]括起来表示为可选)
| 函数 | 作用 |
|---|---|
| int(x[,base]) | 将x转换为一个整数，第二个参数是指定前面字符串的进制类型 |
| float(x) | 将x转换到一个浮点数 |
| complex(real [,imag]) | 创建一个复数 |
| str(x) | 将对象x转换为字符串 |
| repr(x) | 将对象x转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列s转换为一个元组 |
| list(s) | 将序列s转换为一个列表 |
| chr(x) | 将一个整数转换为一个字符 |
| unichr(x) | 将一个整数转换为Unicode字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
| bin(x) | 将一个整数转换为一个二进制字符串 |
数学函数：
| 函数 | 作用 |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1, x2,...) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,...) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同， 整数部分以浮点型表示。 |
| pow(x, y) | x的y次方 |
| round(x [,n]) | 返回浮点数x的四舍五入值，如给出n值，则代表舍入到 小数点后的位数。 |
| sqrt(x) | 返回数字x的平方根，数字可以为负数，返回类型为实数， 如math.sqrt(4)返回 2+0j |
3) 布尔类型(Bool)
用**
True
和
False
**来表示真假，也可以当做整数来对待，True为1， False为0，但是不建议用来参与运算！
4) 列表(List)
类似于数组，有序，内容长度可变，使用中括号[]表示，元素间用逗号分隔， 元素的数据类型可以不一样！用法示例如下(dir(list)可以查看所有的属性与方法j)： (Tip：列表可嵌套，如果想访问列表中的列表中的某个值可以写多个[],比如：list1[1][2])
list1 = [1,2.0,"a",True] # 定义列表 print(list1[1]) # 通过[下标]访问元素，从0开始，结果输出：2.0 print(list1[1:3]) # 支持截取，比如这里的[1:3]，结果输出：[2.0, 'a'] print(list1[1:3:2]) # 还可以有第三个参数，步长，默认为1，结果输出:[2.0] print(list1[2:]) # 输出结果：['a', True] print(list1[-2]) # 负数的话从后面开始访问，结果输出：a print(list1.index("a")) # 返回参数在列表中的位置，结果输出：2 # 修改列表元素 list1[1] = 3.0 # 直接获得元素后进行修改，此时列表元素：[1, 3.0, 'a', True] # 添加元素 list1.append('Jay') # 追加一个元素，此时列表元素：[1, 2.0, 'a', True, 'Jay'] list1.insert(2,'pig') # 插入一个元素，此时列表元素：[1, 2.0, 'pig', 'a', True] print(list1.pop()) # 移除最后一个元素，并返回元素的值，结果输出：True # 删除元素 del list1[0] # 删除索引位置的值，此时列表元素：[2.0, 'a', True] list1.remove('a') # 删除指定的元素值，此时列表元素：[1, 2.0, True] # 其他(使用+号可以组合列表，*号可以重复列表) print(list1+list1) # 输出结果：[1, 2.0, 'a', True, 1, 2.0, 'a', True] print(list1*2) # 输出结果：[1, 2.0, 'a', True, 1, 2.0, 'a', True] print('a' in list1) # 判断列表中是否有此元素，输出结果：True print('b' not in list1) # 判断原始中是不是没有这个元素，输出结果：True for x in list: # 迭代遍历列表 print(len(list1)) # 获得列表长度，结果输出：4 print(list1.count(1)) # 统计某个元素在列表中出现的次数，结果输出：2，因为True的值也是1 max(list1) # 获得列表中的元素最大值，列表元素类型需要为数字 min(list1) # 获得列表中的元素最小值，列表元素类型需要为数字 list1.sort() # 对原列表元素进行排序，本地排序(会修改值)，返回None， # 只能比较数字！默认从小到大，从大到小可以用可选参数，括号里加上： # key = lambda x:-1*x list1.reverse() # 反转列表元素，会修改列表，返回None list2 = list1.copy() # 拷贝列表，重新开辟了内存空间！和等号赋值不一样！ list(tuple) # 将元组或字符串转换为列表5) 元组(tuple)
受限的列表，元组中的元素不能修改，使用小括号()表示。 有一点要注意的是：当元组中只有一个元素，需要在元素后添加逗号， 否则会当做括号运算符使用！元组可以当做不能修改的参数传递给函数， 而且元组所占用的内存较小。使用的话，除了没有修改元组元素的方法外， 其他的和列表的方法基本一致。
另外元组中的元素不能删除，但是可以使用del语句来删除整个元组， 不过比较少用，因为Python回收机制会在这个元组不再被使用时自动删除 (和Java的gc有点像～) 还可以使用**
tuple(list)
**将字符串或列表转换为元组。
输出结果：
6) 字典(dict)
和列表，元组通过下标序列来索引元素不同，字典使用**
键值对
的形式来存储 数据，通过键来索引值**，创建字典时，键不能重复，重复后面的会覆盖！ 因为键必须不可变，所以键可用数字，字符串或元组，但是不能用列表！ 使用**冒号:分割键与值，多个键值对用逗号,**分隔；字典也是支持嵌套的！ 用法示例如下：
dict1 = {} # 定义一个空字典 dict2 = {'a': 1, 'b': 2, 3: "c"} # 定义一个普通字典 dict4 = dict2.copy() # 浅复制一个字典 # 可以使用fromkeys创建并返回新的字典，有两个参数，键和键对应的值 # 值可以不提供，默认None，不过有个小细节要注意，下面的例子输出 # 的结果是：{1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']} list1 = [1, 2, 3] list2 = ['a', 'b', 'c'] dict3 = {} dict3 = dict3.fromkeys(list1, list2) print(dict3) # 通过键查询对应的值，如果没有这个键会报错TypeError，这里输出结果：2 print(dict2['b']) print(dict2.get("d")) # 通过get()方法查询键对应的值，没有的话会返回None # 还可以加上一个默认的返回参数get(x,y) print(dict2.setdefault("d")) # 和get()类似，如果找不到键的话会自动添加 键:None print("d" in dict2) # 字典中是否有此键，这里输出结果：False print("d" not in dict2) # 字典中是否没有此键，这里输出结果：True print(dict2.keys()) # 返回字典中所有的键，这里输出结果：dict_keys(['a', 3, 'b']) print(dict2.values()) # 返回字典中所有的值，这里输出结果：dict_values([1, 'c', 2]) print(dict2.items()) # 返回字典中所有的键值对，这里输出结果： # dict_items([('a', 1), (3, 'c'), ('b', 2)]) # 修改键对应的值，此时字典元素：{3: 'c', 'a': 1, 'b': 'HaHa'} dict2['b'] = 'HaHa' dict2.update(b:'Pig') # 使用update方法可以更新键对应的值，不过键需要为字符串！ # 删除字典元素 del(dict2['b']) # 删除某个键值对，此时字典元素：{3: 'c', 'a': 1} dict2.clear() # 移除字典中所有的键值对，此时剩下空字典：{} del dict2 # 删除整个字典，删除后无法再重复引用！！！ print(dict2.pop('a')) # 根据键删除对应的值，返回被删除的值。 print(dict2.popitem()) # 删除一个项，随机，比如：('b', 2) # 遍历字典： for d in dict2: print("%s:%s" % (d, dict2.get(d))) for (k,v) in dict2.items(): print("%s:%s" % (k, v))7) 集合(set)
集合中的存储的元素无序且不重复，所以你无法去索引某个具体的元素； 使用大括号{}包裹元素，逗号分隔，如果有重复的元素会被自动剔除！ 另外有一点要注意的是，如果是创建空集合必须使用set()，而不能用{}， 通过上面我们也知道了**{}的话是直接创建一个空字典**！ 用法示例如下：
set1 = set() # 创建空集合 set2 = {1, 2, 3, 4, 5, 1} # 普通方式创建集合 print(set2) # 重复元素会被自动删除，输出结果：{1, 2, 3, 4, 5} set3 = set('12345') # 字符串 print(set3) # 输出：{'2', '5', '3', '4', '1'}，集合元素无序 print(6 in set2) # 判断集合中是否有此元素：输出结果：False print(6 not in set2) # 判断集合中是否有此元素：输出结果：True set2.add("6") # 添加元素 print(set2) # 输出结果：{1, 2, 3, 4, 5, '6'} set2.remove(2) # 删除元素，如果删除的元素不存在会报错 print(set2) # 输出结果：{1, 3, 4, 5, '6'} # 遍历集合，输出结果： 1 3 4 5 6 for data in set2: print(data, end="\t") # 使用frozenset()函数定义不可变集合 set4 = frozenset({1, 2, 3, 4, 5})8) 字符串
Python里对处理字符串可是日常，熟练掌握字符串的处理非常重要。 可以使用**
单引号('')
或者
双引号("")
来修饰字符串， 如果想让字符串包含换行缩进等格式时，可以使用
三括号('''''')
** 来修饰，一般要打印段落文字的时候可以用这个。 另外，字符串定义后就不能修改元素了，比如下面str1[0] = 'x'是会报错的， 只能通过+,*，分片等方式进行拼接，间接得到相同的字符串内容，不过却不是原来 的字符了，变量指向了新的字符串，而旧的会被py的回收机制回收掉！
访问字符串：
str1 = "Hello Python" print(str1[3]) # 输出结果：l print(str1[2:]) # 输出结果：llo Python print(str1[2:5]) # 输出结果：llo print(str1[2:10:2]) # 输出结果：loPt print(str1[0:8] + str1[8:]) # 输出结果：Hello Python str2 = str1[6:] * 3 print(str2) # 输出结果：PythonPythonPython
转义字符：
| 转义字符 | 作用 | 转义字符 | 作用 | 转义字符 | 作用 |
|---|---|---|---|---|---|
行尾的\ | 续行符 | \\ | 反斜杠 | \' | 单引号 |
\a | 响铃 | \b | 退格 | \e | 转义 |
\000 | 空 | \n | 换行 | \v | 纵向制表符 |
\t | 横向制表符 | \r | 回车 | \f | 换页 |
\o | 八进制数代表字符 | \\x | 十六进制数代表字符 |
各种内置方法：
| 方法名 | 作用 |
|---|---|
| capitalize() | 把字符串的第一个字符改为大写 |
| casefold() | 把整个字符串的所有字符改为小写 |
| center(width) | 将字符串居中，并使用空格填充至长度width的新字符串 |
| count(sub[,start[,end]]) | 返同sub在字符申里边出现的次数， start和end参数表示范围，可选 |
| encode(encoding= 'utf-8 ',errors='strict') | 以encoding指定的编码格式对字符串进行编码 |
| endswith(sub[,start[,end]]) | 检查字符串是否以sub 子字符串结束，如果是返回True， 否则返回False。start和end参数表示范围，可选 |
| expandtabs([tabsize= 8]) | 把字符串中的tab符号(\t)转换为空格，如不指定参数， 默认的空格数是tabsize=8 |
| find(sub[,start[,end]]) | 检测sub是否包含在字符串中，如果有则返回索引值， 否则返回-1,start和end参数表示范围，可选 |
| index(sub[,start[,end]]) | 跟find方法一样，不过如果sub不在string中会产生一个异常 |
| isalnum() | 如果字符串中至少有一个字符，并且所有字符都是 字母或数字则返回True，否则返回False |
| isalpha() | 如果字符串至少有一个字符串，并且所有字符都是 字母则返回True，否则返回False |
| isdecimal() | 如果字符串只包含十进制数字则返回True，否则返回False |
| isdigit() | 如果字符串只包含数字则返回True，否则返回False |
| islower() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符 都是小写，则返回True，否则返回False |
| isnumeric() | 如果字符串中只包含数字字符，则返回True，否则返回False |
| isspace() | 如果字符串中只包含空格，则返回True，否则返回False |
| istitle() | 如果字符串是标题化(所有单词大写开头，其余小写)， 则返回True，否则返回False |
| isupper() | 如果字符串中至少包含一个区分大小写的字符，并且这些 字符都是大写，则返回True，否则返回False |
| join(sub) | 以字符串作为分隔符，插入到sub中所有的字符之间，使用+去拼接大量 字符串的时候是很低效率的，因为加号拼接会引起内存赋值一级垃圾回收 操作，此时用join来拼接效率会高一些，比如: ''.join(['Hello','Python']) |
| ljust(width) | 返回一个左对齐的字符串，并使用空格填充至长度为width的新字符串 |
| lower() | 转换字符串所有大写字符为小写 |
| lstrip() | 去除字符串左边的所有空格 |
| partition(sub) | 找到子字符串sub，把字符串分割成3元组(前，pre，后) 如果字符串中不包含则返回('原字符串','','') |
| replace(old, new[,count]) | 把字符串中的old子字符串替换成new，如果count指定， 则替换次数不超过count次 |
| rfind(sub[,start[,end]]) | 和find()方法类似，不过是从右开始查找 |
| rindex(sub[,start[,end]]) | 和index()方法类似，不过是从右开始查找 |
| rjust(width) | 返回一个右对齐的字符串，并使用空格填充至长度为width的新字符串 |
| rpartition(sub) | 类似于partition()，不过是从右边开始查找 |
| rstrip() | 删除字符串末尾的空格 |
| split(sep=None,maxsplit=-1) | 不带参数默认是以空格为分隔符切片字符串，如果maxspli参数t 右设置，则仅分隔maxsplit个子字符串，返回切片后的子字符串拼接的列表 |
| splitlines([keepends]) | 按照'\n'分隔，返回一个包含各行作为元素的列表，如果keepends参数 指定，则返回前keepends行 |
| startswith(prefix[,start[,end]]) | 检查字符串是否以prefix开头，是则返回True，否则返回False。 start和end参数可以指定范围检查，可选 |
| strip([chars]) | 删除字符串前边和后边所有的空格，chars参数可定制删除的字符串，可选 |
| swapcase() | 反转字符串中的大小写 |
| title() | 返回标题化(所有的单词都是以大写开始，其余字母小写)的字符串 |
| translate(table) | 按照table的规则(可由str.maketrans('a','b')定制)转换字符串中的字符 |
| upper() | 转换字符串中所有的小写字符为大写 |
| zfill(width) | 返回长度为width的字符串，原字符串右对齐，前边用0填充 |
字符串格式化：
其实就是format方法的使用而已，示例如下：
# 位置参数 str1 = "{0}生{1}，{2}{3}！".format("人","苦短","我用","Python") print(str1) # 输出结果：人生苦短，我用Python！ # 关键字参数 str1 = "{a}生{c}，{b}{d}！".format(a = "人", c = "苦短",b = "我用",d = "Python") print(str1) # 输出结果：人生苦短，我用Python！ # 位置参数可以与关键字参数一起使用，不过位置参数需要在关键字参数前，否则会报错！ # 另外还有个叫替换域的东西，冒号代表格式化符号开始，比如下面的例子： str1 = "{0}:{1:.4}".format("圆周率", 3.1415926) print(str1) # 输出结果：圆周率:3.142格式化操作符：%，这个就不说了，和上面print()那里的一致！
好了，今天的知识就分享到这里，欢迎关注爱编程的南风，私信关键词：学习资料，获取更多学习资源，如果文章对你有有帮助，请收藏关注，在今后与你分享更多学习python的文章。同时欢迎在下面评论区留言如何学习python。