Python与C++、Java区别对比学习

int* arr = new int[10];

name = "Tom"
age = 20
print("My name is {}, and I'm {} years old".format(name, age))

name = "Tom"
age = 20
print("My name is %s, and I'm %d years old" % (name, age))

#include <stdio.h>
int main()
{
    char name[] = "Tom";
    int age = 20;
    printf("My name is %s, and I'm %d years old\n", name, age);
    return 0;
}

#include <iostream>
using namespace std;
int main()
{
    char name[] = "Tom";
    int age = 20;
    cout << "My name is " << name << ", and I'm " << age << " years old" << endl;
    return 0;
}

public class Main {
    public static void main(String[] args) {
        String name = "Tom";
        int age = 20;
        System.out.printf("My name is %s, and I'm %d years old\n", name, age);
    }
}

# 省略字段名传递位置参数
print('我叫{}，今年{}岁。'.format('小明', 18))
"""
我叫小明，今年18岁。
"""

# 大括号个数可以少于位置参数的个数
print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
"""
我爱吃香蕉和苹果。
"""

# 大括号个数多于位置参数的个数则会报错
# print('我还吃{}和{}。'.format('西红柿'))
"""
IndexError: tuple index out of range
"""

# 通过数字形式的简单字段名传递位置参数
print('身高{0}，家住{1}。'.format(1.8, '铜锣湾'))
"""
身高1.8，家住铜锣湾
"""

# 数字形式的简单字段名可以重复使用。
print('我爱{0}。\n她今年{1}。\n我也爱{0}。'.format('阿香', 17))
"""
我爱阿香。
她今年17。
我也爱阿香。
"""

# 体会把所有位置参数整体当成元组来取值
print('阿香爱吃{1}、{3}和{0}。'.format(
    '榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
"""
阿香爱吃臭豆腐、鲱鱼罐头和榴莲。
"""

# 尝试一下越界错误
# print('{1}'.format('错误用法'))
"""
IndexError: tuple index out of range
"""

# 使用变量名形式的简单字段名传递关键字参数
print('我大哥是{name}，今年{age}岁。'.format(name='阿飞', age=20))
"""
我大哥是阿飞，今年20岁。
"""

# 关键字参数的顺序可以随意调换
print('我大哥是{name}，今年{age}岁。'.format(age=20, name='阿飞'))
"""
我大哥是阿飞，今年20岁。
"""

# 混合使用数字形式和变量名形式的字段名
# 可以同时传递位置参数和关键字参数
print('这是一个关于{0}、{1}和{girl}的故事。'.format(
    '小明', '阿飞', girl='阿香'))
"""
这是一个关于小明、阿飞和阿香的故事。
"""

# 但是关键字参数必须位于位置参数之后
# print('这是一个关于{0}、{1}和{girl}的故事。'.format(
    # '小明', girl='阿香' , '阿飞'))
"""
SyntaxError: positional argument follows keyword argument
"""

# 数字也可以省略
print('这是一个关于{}、{}和{girl}的故事。'.format(
    '小明', '阿飞', girl='阿香'))

# 但是省略字段名不能和数字形式的字段名同时出现
# print('这是一个关于{}、{1}和{girl}的故事。'.format(
#     '小明', '阿飞', girl='阿香'))
"""
ValueError: cannot switch from automatic field numbering to manual field specification
"""

# 使用元组传参
infos = '钢铁侠', 66, '小辣椒'
print('我是{}，身价{}亿。'.format(*infos))
"""
我是钢铁侠，身家66亿。
"""
print('我是{2}，身价{1}亿。'.format(*infos))
"""
我是小辣椒，身家66亿。
"""

# 使用字典传参
venom = {'name': '毒液', 'weakness': '火'}
print('我是{name}，我怕{weakness}。'.format(**venom))
"""
我是毒液，我怕火。
"""

# 同时使用元组和字典传参
hulk = '绿巨人', '拳头'
captain = {'name': '美国队长', 'weapon': '盾'}
print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
print('我是{name}, 我怕{1}。'.format(*hulk, **captain))

"""
我是绿巨人, 我怕盾。
我是美国队长, 我怕拳头。
"""

# 同时使用位置参数、元组、关键字参数、字典传参
# 注意：
# 位置参数要在关键字参数前面
# *元组要在**字典前面
tup = '鹰眼',
dic = {'weapon': '箭'}
text = '我是{1}，我怕{weakness}。我是{0}，我用{weapon}。'
text = text.format(
    *tup, '黑寡妇', weakness='男人', **dic)
print(text)
"""
我是黑寡妇，我怕男人。我是鹰眼，我用箭。
"""

class Person(object):
  def __init__(self,name,age,gender):
    self.name = name
    self.age = age
    self.gender = gender
p = Person('zhangsan',18,'female')
print('姓名是{0.name},年龄是{0.age},性别是{0.gender}'.format(p))
print('姓名是{.name}'.format(p))  # 只有一个替换字段时，可以省略数字

# 中括号用法：用列表传递位置参数
infos = ['阿星', 9527]
food = ['霸王花', '爆米花']
print('我叫{0[0]}，警号{0[1]}，爱吃{1[0]}。'.format(
    infos, food))
"""
我叫阿星，警号9527，爱吃霸王花。
"""

# 中括号用法：用元组传递位置参数
food = ('僵尸', '脑子')
print('我叫{0[0]}，年龄{1}，爱吃{0[1]}。'.format(
    food, 66))
"""
我叫僵尸，年龄66，爱吃脑子。
"""

# 中括号用法：用字典传递位置参数
dic = dict(name='阿星', pid=9527)
print('我是{[name]}！'.format(
    dic))
# 多个替换字段，不能省略数字
print('我是{0[name]}，警号{0[pid]}。'.format(
    dic))
"""
我是阿星！
我是阿星，警号9527。
"""

# 转换字段
print('I am {!s}!'.format('Bruce Lee 李小龙'))
print('I am {!r}!'.format('Bruce Lee 李小龙'))
print('I am {!a}!'.format('Bruce Lee 李小龙'))
"""
I am Bruce Lee 李小龙!
I am 'Bruce Lee 李小龙'!
I am 'Bruce Lee \u674e\u5c0f\u9f99'!
"""

for (初始化表达式; 布尔表达式; 更新表达式) {
    // 代码块
}

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> vec = {1, 2, 3, 4, 5};
    for (int i = 0; i < vec.size(); i++)
    {
        cout << vec[i] << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> vec = {1, 2, 3, 4, 5};
    for (int x : vec)
    {
        cout << x << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> vec = {1, 2, 3, 4, 5};
    for (vector<int>::iterator it = vec.begin(); it != vec.end(); it++)
    {
        cout << *it << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> vec = {1, 2, 3, 4, 5};
    for (auto it = vec.begin(); it != vec.end(); it++)
    {
        cout << *it << " ";
    }
    return 0;
}

for (初始化表达式; 布尔表达式; 更新表达式) {
    // 代码块
}

for (数据类型 变量名: 数组名/集合名) {
    // 代码块
}

for 变量 in 序列:
    // 代码块

for i in range(10):
    // 代码块

for i in range(5):
    print(i)

str = "Hello, world!"
print(len(str)) # 输出 13

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str = "Hello, world!";
  cout << str.size() << endl; // 输出 13
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str = "Hello, world!";
    System.out.println(str.length()); // 输出 13
  }
}

str1 = "Hello, world!"
str2 = "Hello, Python!"
if str1 == str2:
  print("相等")
else:
  print("不相等") # 输出 "不相等"

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str1 = "Hello, world!";
  string str2 = "Hello, C++!";
  if (str1 == str2) {
    cout << "相等" << endl;
  } else {
    cout << "不相等" << endl; // 输出 "不相等"
  }C++
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str1 = "Hello, world!";
    String str2 = "Hello, Java!";
    if (str1.equals(str2)) {
      System.out.println("相等");
    } else {
      System.out.println("不相等"); // 输出 "不相等"
    }
  }
}

str = "Hello, world!"
if "world" in str:
  print("包含")
else:
  print("不包含") # 输出 "包含"

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str = "Hello, world!";
  if (str.find("world") != string::npos) {
    cout << "包含" << endl;
  } else {
    cout << "不包含" << endl; // 输出 "包含"
  }
  return 0;
}

string substr (size_t pos, size_t len) const;

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str = "Hello, world!";
  string sub = str.substr(7, 5);
  cout << sub << endl; // 输出 "world"
  return 0;
}

String substring(int beginIndex, int endIndex);

public class Main {
  public static void main(String[] args) {
    String str = "Hello, world!";
    String sub = str.substring(7, 12);
    System.out.println(sub); // 输出 "world"
  }
}

string[start:end:step]

str = "Hello, world!"
sub = str[7:12]
print(sub) # 输出 "world"

s = "ABCDEFG"
s[1:4]#BCD
s[-3:]#EFG
s[:]#ABCDEF
 
s[::-1]#GFEDCBA
s[::-2]#GECA 倒着取且步长为2
s[0:6:-2]#无法取到任何值，注意方向，从0向左取
s[6:0:-2]#GECA

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str1 = "Hello";
  string str2 = "world!";
  string newStr = str1 + ", " + str2 + "!";
  cout << newStr << endl; // 输出 "Hello, world!"
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str1 = "Hello";
    String str2 = "world!";
    String newStr = str1 + ", " + str2 + "!";
    System.out.println(newStr); // 输出 "Hello, world!"
  }
}

str1 = "Hello"
str2 = "world!"
newStr = str1 + ", " + str2 + "!"
print(newStr) # 输出 "Hello, world!"

public class Main {
  public static void main(String[] args) {
    String str1 = "Hello";
    String str2 = "world!";
    String newStr = str1.concat(", ").concat(str2).concat("!");
    System.out.println(newStr); // 输出 "Hello, world!"
  }
}

strList = ["Hello", "world!"]
newStr = ", ".join(strList) + "!"
print(newStr) # 输出 "Hello, world!"

public class Main {
  public static void main(String[] args) {
    String str = "apple,banana,orange";
    String[] strArr = str.split(",");
    for (String s : strArr) {
      System.out.println(s);
    }
  }
}

str = "apple,banana,orange"
strList = str.split(",")
for s in strList:
  print(s)

#include <iostream>
#include <sstream>
#include <string>
#include <vector>

using namespace std;

int main() {
  string str = "apple,banana,orange";
  vector<string> strVec;
  istringstream iss(str);
  string s;
  while (getline(iss, s, ',')) {
    strVec.push_back(s);
  }
  for (string s : strVec) {
    cout << s << endl;
  }
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str = "hello, world!";
    String newStr = str.replace("world", "Java");
    System.out.println(newStr);
  }
}

str = "hello, world!"
newStr = str.replace("world", "Python")
print(newStr)

#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

int main() {
  string str = "hello, world!";
  replace(str.begin(), str.end(), ',', ':');
  cout << str << endl;
  return 0;
}

#include <iostream>
#include <regex>
#include <string>

using namespace std;

int main() {
  string str = "hello, world!";
  regex reg(",");
  string newStr = regex_replace(str, reg, ":");
  cout << newStr << endl;
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str = "hello, world!";
    String newStr = str.replaceAll(",", ":");
    System.out.println(newStr);
  }
}

import re

str = "hello, world!"
newStr = re.sub(",", ":", str)
print(newStr)

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str = "123";
  int num = stoi(str);
  cout << num << endl;
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str = "123";
    int num = Integer.parseInt(str);
    System.out.println(num);
  }
}

str = "123"
num = int(str)
print(num)

#include <iostream>
#include <string>

using namespace std;

int main() {
  int num = 123;
  string str = to_string(num);
  cout << str << endl;
  return 0;
}

public class Main {
  public static void main(String[] args) {
    int num = 123;
    String str = String.valueOf(num);
    System.out.println(str);
  }
}

num = 123
str = str(num)
print(str)

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str = "3.14";
  float num = stof(str);
  cout << num << endl;
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str = "3.14";
    float num = Float.parseFloat(str);
    System.out.println(num);
  }
}

str = "3.14"
num = float(str)
print(num)

#include <iostream>
#include <string>

using namespace std;

int main() {
  float num = 3.14;
  string str = to_string(num);
  cout << str << endl;
  return 0;
}

public class Main {
  public static void main(String[] args) {
    float num = 3.14f;
    String str = String.valueOf(num);
    System.out.println(str);
  }
}

num = 3.14
str = str(num)
print(str)

#include <iostream>
#include <string>

using namespace std;

int main() {
  string str = "true";
  bool value = stoi(str);
  cout << value << endl;
  return 0;
}

public class Main {
  public static void main(String[] args) {
    String str = "true";
    boolean value = Boolean.parseBoolean(str);
    System.out.println(value);
  }
}

str = "True"
value = bool(str)
print(value)

#include <iostream>
#include <string>

using namespace std;

int main() {
  bool value = true;
  string str = to_string(value);
  cout << str << endl;
  return 0;
}

public class Main {
  public static void main(String[] args) {
    boolean value = true;
    String str = String.valueOf(value);
    System.out.println(str);
  }
}

value = True
str = str(value)
print(str)

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(len(mystr))  # 17 获取字符串的长度

S.find(sub[, start[, end]]) -> int

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.find('好风光'))  # 10 '好风光'第一次出现时，'好'所在的位置
print(mystr.find('你好'))  # -1  '你好'不存在，返回 -1
print(mystr.find('风', 12))  # 15 从下标12开始查找'风',找到风所在的位置试15
print(mystr.find('风光',1,10)) # -1 从下标1开始到12查找"风光",未找到，返回 -1

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rfind('好')) # 14

S.index(sub[, start[, end]]) -> int

S.startswith(prefix[, start[, end]]) -> bool

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.startswith('今'))  # True
print(mystr.startswith('今日')) # False

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.endswith('好风光')) #True
print(mystr.endswith('好日子')) #False

mystr = 'hello'
print(mystr.isalpha())  # True
mystr = 'hello world'
print(mystr.isalpha()) # False 因为中间有空格

mystr = '1234'
print(mystr.isdigit()) # True
mystr = '123.4'
print(mystr.isdigit()) # False
mystr = '-1234'
print(mystr.isdigit()) # False

mystr = 'abcd'
print(mystr.isalnum())  # True
mystr = '1234'
print(mystr.isalnum()) # True
mystr = 'abcd1234'
print(mystr.isalnum()) # True
mystr = 'abcd1234_'
print(mystr.isalnum()) # False

mystr = ''
print(mystr.isspace()) # False mystr是一个空字符串
mystr = '  '
print(mystr.isspace()) # True 只有空格
mystr = ' d'
print(mystr.isspace()) # False 除了空格外还有其他内容

S.count(sub, start, end) -> int

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.count('好'))  # 3. '好'字出现三次

mystr = '今天天气好晴朗，处处好风光呀好风光'
newstr = mystr.replace('好', '坏')
print(mystr)  # 今天天气好晴朗，处处好风光呀好风光  原字符串未改变！
print(newstr)  # 今天天气坏晴朗，处处坏风光呀坏风光 得到的新字符串里，'好'被修改成了'坏'

newstr = mystr.replace('好','坏',2)  # 指定了替换的次数
print(newstr) # 今天天气坏晴朗，处处坏风光呀好风光 只有两处的'好'被替换成了'坏'

mystr = '今天天气好晴朗，处处好风光呀好风光'
result = mystr.split() # 没有指定分隔符，默认使用空格，换行等空白字符进行分隔
print(result) #['今天天气好晴朗，处处好风光呀好风光'] 没有空白字符，所以，字符串未被分隔

result = mystr.split('好')  # 以 '好' 为分隔符
print(result) # ['今天天气', '晴朗，处处','风光呀,'风光']

result = mystr.split("好",2) # 以 '好' 为分隔符，最多切割成3份
print(result) # ['今天天气', '晴朗，处处', '风光呀好风光']

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rsplit('好',1))  #['今天天气好晴朗，处处好风光呀', '风光']

mystr = 'hello \nworld'
print(mystr.splitlines())
s = '''
今天天气好晴朗!
处处好风光呀好风光!
'''
result = s.splitlines()
print(result)#['', '今天天气好晴朗!', '处处好风光呀好风光!']

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.partition('好'))  # ('今天天气', '好', '晴朗，处处好风光呀好风光')

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rpartition('好'))   # ('今天天气好晴朗，处处好风光呀', '好', '风光')

mystr = 'hello world'
print(mystr.capitalize()) # Hello world

mystr = 'hello world'
print(mystr.title()) # Hello World

mystr = 'hElLo WorLD'
print(mystr.lower()) # hello world

mystr = 'hello world'
print(mystr.upper())  #HELLO WORLD

username = input("请输入用户名：")#请输入用户名：admin    '\n'
print(len(username))#9

str = 'hello'
print(str.ljust(10))  # hello     在右边补了五个空格

str = 'hello'
print(str.rjust(10))  #      hello在左边补了五个空格

str = 'hello'
print(str.center(10))  #  hello   两端加空格，让内容居中

mystr = '    he   llo      '
print(str.lstrip())  #he   llo      只去掉了左边的空格，中间和右边的空格被保留

mystr = '    he   llo      '
print(str.rstrip())  #    he   llo右边的空格被删除

str = '    he   llo      '
print(str.strip())  #he   llo

S.join(iterable)

mystr = 'a'
print(mystr.join('hxmdq'))  #haxamadaq  把hxmd一个个取出，并在后面添加字符a. 最后的 q 保留，没有加 a
print(mystr.join(['hi','hello','good']))  #hiahelloagood

txt = '_'
print(txt.join(['hi','hello','good'])) #hi_hello_good
print(txt.join(('good','hi','hello'))) #good_hi_hello

#查找：find,rfind
#例子：截取指定字符串
path = "https://www.bilibili.com/video/BV1R7411F7JV/?p=32&spm_id_from=pageDriver&vd_source=547f6e585f4f9c01d3cdb8fe3dcd38e9"
name = path[path.rfind('=') + 1:] #path.rfind('=')返回的是下标
print(name)#547f6e585f4f9c01d3cdb8fe3dcd38e9

path = "https://www.bilibili.com/video/BV1R7411F7JV/?p=32&spm_id_from=pageDriver&vd_source=547f6e585f4f9c01d3cdb8fe3dcd38e9"
print(path.rfind('bilibili'))#12

#判断：startswith,endswith,isdigit,isalnum,isspace
#返回值都是bool类型
path = "https://www.bilibili.com/video/BV1R7411F7JV/?p=32&spm_id_from=pageDriver&vd_source=547f6e585f4f9c01d3cdb8fe3dcd38e9"
result = path.startswith('http')#返回的是bool类型
print(result)#True

s = "a1234"
print(s.isdigit)

#练习
'''
模拟文件上传，键盘输入文件名abc.jpg,判断文件名abc是否大于6位以上，扩展名是否是：jpg，gif，png格式,如果不是则提示上传失败，如果名字不满足条件，而扩展名满足条件则随机生成一个6位数子组成的文件名，打印成功上传xxxx.png
'''
import random

file = input()
if file.endswith('jpg') or file.endswith('gif') or file.endswith('png'):
    i = file.find('.')
    name = file[:i]
    if len(name)<6:
        n = random.randint(100000,999999)
        file = str(n) + file[i:] #T:所有的字符串操作都不会改变原来的字符串
        print("成功上传%s"%file)
else:
    print("文件格式错误")
    
'''
模拟随机产生验证码
'''
filename = ""
s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456"
for i in range(4):
    index = random.randint(0,len(s)-1)
    filename += s[index]
print(filename)

print(ord('a'))  # 使用ord方法，可以获取一个字符对应的编码
print(chr(100))  # 使用chr方法，可以获取一个编码对应的字符

s1 = '你'.encode('utf8')  # 将字符 你 按照utf8格式编码称为二进制
print(type(s1))  # <class 'bytes'>
print(s1)  # b'\xe4\xbd\xa0'

s2 = s1.decode('utf8') # 将二进制按照utf8格式解码称为字符串
print(s2)

s3 = '你'.encode('gbk') # 将字符 你 按照gbk格式转换称为二进制
print(s3)  # b'\xc4\xe3'

s4 = s3.decode('gbk')  # 将二进制按照gbk格式解码称为字符
print(s4)

tmp = ['xiaoWang',180, 65.0]

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])

xiaoWang
xiaoZhang
xiaoHua

#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----添加之前，列表A的数据-----A=%s" % A)

#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)

print("-----添加之后，列表A的数据-----A=%s" % A)

strs = ['a','b','m','s']
strs.insert(3,'h')
print(strs)  # ['a', 'b', 'm', 'h', 's']

a = ['a','b','c']
b = ['d','e','f']
a.extend(b)
print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 将 b 添加到 a 里
print(b) # ['d','e','f'] b的内容不变

#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----修改之前，列表A的数据-----A=%s" % A)

#修改元素
A[1] = 'xiaoLu'

print("-----修改之后，列表A的数据-----A=%s" % A)

#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']

#获取用户要查找的名字
findName = input('请输入要查找的姓名:')

#查找是否存在
if findName in nameList:
    print('在列表中找到了相同的名字')
else:

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
del movieName[2]
print('------删除之后------movieName=%s' % movieName)

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
movieName.pop()
print('------删除之后------movieName=%s' % movieName)

movieName.pop(-1)#['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人']
movieName.pop(8)#报错

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
movieName.remove('指环王')
print('------删除之后------movieName=%s' % movieName)

list1 = ['火腿','酸奶','酸奶','辣条','薯条','面包','薯条','酸奶','酸奶']
for i in list1:
    if i == '酸奶':
    	list1.remove(i)
print(list1)#['火腿', '辣条', '薯条', '面包', '薯条', '酸奶', '酸奶']
#结果发现如果有连续的元素时会出现漏删操作，因为删除后列表元素减一，但是for循环的下标不变，继续进行，所以跳过了下一个元素。
#优化：
n = 0
while n < len(list1):
    if list1[n]  == '酸奶':
        list1.remove('酸奶')
    else:
        n+=1
        
#错误写法
#for i in range(len(list1)):
#     if list1[i] == '酸奶'：
#     	list1.remove('酸奶')
#         i -= 1
# print(list1)

#正确写法1
result_li = []
for i in list1:
    if i != elem:
        result_li.append(i)
list1 = result_li
print(li)
        
#正确写法2
for i in list1[::-1]:
    if i == '酸奶':
        list1.remove(i)#remove从左往右寻找删除
print(list1)

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()  # 逆置，不排序
>>> a
[3, 2, 4, 1]
>>> a.sort()  # 默认从小到大排序
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)  # 从大到小排序
>>> a
[4, 3, 2, 1]

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)  # 获取列表长度
i = 0
while i<length:
    print(namesList[i])
    i+=1
Copy

xiaoWang
xiaoZhang
xiaoHua
Copy

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)
Copy

xiaoWang
xiaoZhang
xiaoHua
Copy

# 使用中间变量
a = 4
b = 5
c = 0

c = a
a = b
b = c

print(a)
print(b)
Copy

nums = [5, 1, 7, 6, 8, 2, 4, 3]

for j in range(0, len(nums) - 1):
   for i in range(0, len(nums) - 1 - j):
       if nums[i] > nums[i + 1]:
           a = nums[i]
           nums[i] = nums[i+1]
           nums[i+1] = a

print(nums)
Copy

>>> schoolNames = [
... [1, 2, 3],
... [11, 22, 33],
... [111, 222, 333]
... ]
>>> schoolNames[1][2]  # 获取数字 33
33
>>> schoolNames[1][2] = 'abc'  # 把 33 修改为 'abc'
>>> schoolNames
[[1, 2, 3], [11, 22, 'abc'], [111, 222, 333]]
>>> schoolNames[1][2][2]  # 获取 'abc' 里的字符c
'c'
Copy

import random

# 定义一个列表用来保存3个办公室
offices = [[],[],[]]

# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']

i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('办公室%d的人数为:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)
Copy

list1 = [i*2 for i in range(1,10,2)]

a = 12
b = a
b = 13
print(b)
print(a)

nums1 = [1, 5, 8, 9, 10, 12]
nums2 = nums1
nums2[0] = 100
print(nums2)
print(nums1)
Copy

nums1 = [1, 5, 8, 9, 10, 12]
nums2 = nums1.copy()  # 调用列表的copy方法，可以复制出一个新的列表

nums2[0] = 100

# 修改新列表里的数据，不会影响到原有列表里的数据
print(nums2)
print(nums1)
Copy

import copy

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']

# 浅拷贝只会拷贝最外层的对象，里面的数据不会拷贝，而是直接指向
words2 = copy.copy(words1)

words2[0] = '你好'
words2[2][0] = 'no'

print(words1)  # ['hello', 'good', ['no', 'ok'], 'bad']
# wrods2 里的 yes 被修改成了 no
print(words2)  # ['你好', 'good', ['no', 'ok'], 'bad']
Copy

import copy

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']

# 深拷贝会将对象里的所有数据都进行拷贝
words2 = copy.deepcopy(words1)

words2[0] = '你好'
words2[2][0] = 'no'

print(words1)  # ['hello', 'good', ['yes', 'ok'], 'bad']
print(words2)  # ['你好', 'good', ['no', 'ok'], 'bad']
Copy

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']
words2 = words1[:]
words2[0] = '你好'
words2[2][0] = 'no'
print(words1)  # ['hello', 'good', ['no', 'ok'], 'bad']
print(words2) # ['你好', 'good', ['no', 'ok'], 'bad']

>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)
Copy

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
Copy

>>> a = (11)
>>> a
11
>>> type(a)
int
>>> a = (11,)  # 只有一个元素的元组，必须要在元素后写一个逗号
>>> a
(11,)
>>> type(a)
tuple
Copy

# 第1种方式,使用中间变量
a = 4
b = 5
c = 0

c = a
a = b
b = c
print(a)
print(b)

# 第2种方式，直接交换。
a, b = 4, 5
a, b = b, a

print(a)
print(b)

# 定义一个列表保存，姓名、性别、职业
nameList = ['xiaoZhang', '男', '木匠'];

# 当修改职业的时候，需要记忆元素的下标
nameList[2] = '铁匠'  

# 如果列表的顺序发生了变化，添加年龄
nameList = ['xiaoWang', 18, '男',  '铁匠']

# 此时就需要记忆新的下标，才能完成名字的修改
nameList[3] = 'xiaoxiaoWang'
Copy

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国上海'}
info['name']  # 字典使用键来获取对应的值

my_dict = {}
my_dict = dict()

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

my_dict['key4'] = 'value4'
my_dict['key1'] = 'new_value1'

dict.setdefault(key, default_value)

>>> d = {'a': 1, 'b': 2}
>>> d.setdefault('a', 3)
1
>>> d.setdefault('c', 3)
3
>>> print(d)
{'a': 1, 'b': 2, 'c': 3}

del my_dict['key3']

value = my_dict.pop('key2')

key, value = my_dict.popitem()

value = my_dict['key1']

value = my_dict.get('key2', 'default_value')

keys = my_dict.keys()#dict_keys(['name', 'id', 'sex', 'address'])

values = my_dict.values()#dict_values(['班长', 100, 'f', '地球亚洲中国上海'])

items = my_dict.items()#dict_items([('name', '班长'), ('id', 100), ('sex', 'f'), ('address', '地球亚洲中国上海')])

for i in items:
    print(i)   
'''
('name', '班长')
('id', 100)
('sex', 'f')
('address', '地球亚洲中国上海')
'''

for k,v in items:
    print(k,v)
'''
name 班长
id 100
sex f
address 地球亚洲中国上海
'''

length = len(my_dict)

if 'key1' in my_dict:
    print('Key exists in the dictionary')

my_dict.clear()

dict.update([other])

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

dict1.update(dict2)
print(dict1)

{'a': 1, 'b': 3, 'c': 4}

new_dict = dict1.copy()
new_dict.update(dict2)

dict.fromkeys(seq[, value])

keys = ['a', 'b', 'c']

my_dict = dict.fromkeys(keys)
print(my_dict)
# Output: {'a': None, 'b': None, 'c': None}

my_dict = dict.fromkeys(keys,10)
print(my_dict)
# Output: {'a': 10, 'b': 10, 'c': 10}

my_dict = dict.fromkeys(keys,[10,20])
print(my_dict)
# Output: {'a': [10,20], 'b': [10,20], 'c': [10,20]}

my_dict = {"apple": 3, "banana": 5, "orange": 2}

for key, value in my_dict.items():
    print(key, value)

parame = {value01,value02,...}
#或者
set(value)

s.add(x)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

s.update( x )

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

s.remove( x )

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

s.discard( x )
Copy
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

s.pop()
Copy
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)
print(thisset)

# 方法一：调用列表的sort方法
nums2 = list(set(nums))
nums2.sort(reverse=True)
print(nums2)

# 方法二：使用sorted内置函数
print(sorted(list(set(nums)),reverse=True))

x = '1+1'
print(eval(x))  # 2
print(type(eval(x)))  # <class 'int'>

y = '{"name":"zhangsan","age":18}'
print(eval(y))
print(type(eval(y)))  # <class 'dict'>

print(eval('1 > 2'))  # False

eval('input("请输入您的姓名:")')

import json

person = {'name': 'zhangsan', 'age': 18}
x = json.dumps(person)
print(x)  # {"name": "zhangsan", "age": 18}
print(type(x))  # <class 'str'>

nums = [1, 9, 0, 4, 7]
y = json.dumps(nums)
print(y)  # [1, 9, 0, 4, 7]
print(type(y)) # <class 'str'>

words = ('hello','good','yes')
z = json.dumps(words)
print(z) # ["hello", "good", "yes"]
print(type(z)) # <class 'str'>

x = '{"name": "zhangsan", "age": 18}'
person = json.loads(x)
print(person)  # {'name': 'zhangsan', 'age': 18}
print(type(person)) # <class 'dict'>

y = '[1, 9, 0, 4, 7]'
nums = json.loads(y)
print(nums) # [1, 9, 0, 4, 7]
print(type(nums)) # <class 'list'>

>>> "hello " + "world"
'hello world'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')

>>> {1, 6, 9, 10, 12, 3} - {4, 8, 2, 1, 3}
{9, 10, 12, 6}

>>> 'ab' * 4
'ababab'
>>> [1, 2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b') * 4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')

>>> 'llo' in 'hello world'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {"name":"chris", "age":18}
True

>>> a_str = "hello world"
>>> for char in a_str:
...     print(char,end=' ')
...
h e l l o   w o r l d

>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
...     print(num,end=' ')
...
1 2 3 4 5

>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
...     print(num,end=" ")
1 2 3 4 5

nums = [12, 9, 8, 5, 4, 7, 3, 6]

# 将列表 nums 包装成 enumerate 对象
for i, num in enumerate(nums): # i表示元素下标，num表示列表里的元素
    print('第%d个元素是%d' % (i, num))

a = [1, 2, 3]
b = a #a给b赋值是把a的引用地址给了b，python的变量类似与指针
c = b

del a
del b
del c

class A:
    pass

class B:
    pass

a = A()
b = B()

a.b = b
b.a = a

def 函数名():
    代码

# 定义一个函数，能够完成打印信息的功能
def printInfo():
    print('------------------------------------')
    print('         人生苦短，我用Python')
    print('------------------------------------')

print(printInfo)#打印函数名返回的是函数地址

# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()

def add2num(a, b):
    c = a+b
    print c

add2num(11, 22) # 调用带有参数的函数时，需要在小括号中，传递数据

>>> def test(a,b):
...     print(a,b)
... 
>>> test(1,2)  # 位置参数
1 2
>>> test(b=1,a=2)  # 关键字参数
2 1
>>> 
>>> test(b=1,2)  # 关键字参数写在位置参数之前会导致出错
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

library = ["a","b","c","d","e","f"]
#形参
def add_book(bookname):
    library.append(bookname)
    print("引入成功")
    
def show_book(books):
    for book in books:
        print(book)
#调用
add_book('g')
show_book(library)

# 定义全局变量
a = 100

def test1():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据

def test2():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据

# 调用函数
test1()
test2()
Copy

100
100

# 可以使用一次global对多个全局变量进行声明
global a, b
# 还可以用多次global声明都是可以的
# global a
# global b

def test():
    a = 100
    b = 40
    print(locals())  # {'a': 100, 'b': 40}

test()

x = 'good'
y = True
print(globals())  # {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x101710630>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/jiangwei/Desktop/Test/test.py', '__cached__': None, 'test': <function test at 0x101695268>, 'x': 'good', 'y': True}

#求和
def get_sum(a,b):
    r = a + b
    print(r)

get_sum(1,2)#可行
get_sum(2,6,9)#不可行

a,*b,c = 1,2,3,4,5,6
print(a)#1
print(b)#[2,3,4]
print(c)#5

def get_sum(*a):
    print(a)#
    
get_sum(1,2)#(1,2)
get_sum(2,6,9)#(2,6,9)

def get_sum(*args):
	print(*args)#
    s = 0
    for i in args:
        s += i
    print(s)
    
re = [23,434,34,34,54,213,234]
get_sum(re)#报错

def get_sum(*args):
	print(*args)#
    s = 0
    for i in args:
        s += i
    print(s)
    
re = [23,434,34,34,54,213,234]
get_sum(*re)#参数加上*就是拆包

def show_book(**kwargs):
    print(kwargs)
    
show_book()#{}
show_book(bookname='西游记',author='吴承恩',number=5)#{'bookname':'西游记','author':'吴承恩','number':5}

def show_book(**kwargs):
    print(kwargs) #{}
    for k,v in kwargs.items():
        print(k,v)
    
book = {'bookname':'西游记','author':'吴承恩','number':5}
show_book(**book)
'''
bookname 西游记
author 吴承恩
number 5
'''

def show_book(*args,**kwargs):
    print(args)
    print(kwargs)

book = {'bookname':'坏小孩','author':'zzz','number':5}
show_book('龙少','小芳',**book)

def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)
   print("age %d" % age)

# 调用printinfo函数
printinfo(name="miki")  # 在函数执行过程中 age取默认值35
printinfo(age=9 ,name="miki")

name: miki
age: 35
name: miki
age: 9

>>> def printinfo(name, age=35, sex):
...     print name
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]

def test(a, b, *args, **kwargs):
      "函数在声明时，需要两个参数"
    print('a={},b={},args={},kwargs={}'.format(a,b,args,kwargs))

test(2, 3, '你好', 'hi', 'how do you do', name="zhangsan", age=18)
# a=2,b=3,args=('你好', 'hi', 'how do you do'),kwargs={'name': 'zhangsan', 'age': 18}


b = ('hi', '大家好', '今天天气真好')
d = {'name': "zhangsan", "age": 19}

# 注意，在传入参数时的星号问题。
test(10, 20, *b, **d) 
# a=10,b=20,args=('hi', '大家好', '今天天气真好'),kwargs={'name': 'zhangsan', 'age': 19}


# 如果在传值时，不使用星号，会把后面的参数当做 args
test(10,20,b,d)
# a=10,b=20,args=(('hi', '大家好', '今天天气真好'), {'name': 'zhangsan', 'age': 19}),kwargs={}

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)

a = [1, 2, 3]
b = a

a.append(4)
print(b)  # 输出 [1, 2, 3, 4]

def append_item(lst, item):
    lst.append(item)

my_list = [1, 2, 3]
append_item(my_list, 4)
print(my_list)  # 输出 [1, 2, 3, 4]

def capitalize_string(s):
    s[0] = s[0].upper()

my_string = "hello"
capitalize_string(my_string)  # 引发 TypeError 错误

def add2num(a, b):
    c = a+b
    return c  # return 后可以写变量名

def add2num(a, b):
    return a+b  # return 后可以写计算表达式

def add2num(a, b):
    return a,b  # 返回一个元组(a,b)

a,b = add2num(1,2)
print(a,b)#1 2

#定义函数
def add2num(a, b):
    return a+b

#调用函数，顺便保存函数的返回值
result = add2num(100,98)

#因为result已经保存了add2num的返回值，所以接下来就可以使用了
print(result)

198

>>> def test(a,b):
...     "用来完成对2个数求和"  # 函数第一行写一个字符串作为函数文档
...     print("%d"%(a+b))
... 
>>> 
>>> test(11,22)  # 函数可以正常调用
33
>>>
>>> help(test)  # 使用 help 查看test函数的文档说明
Help on function test in module __main__:

test(a, b)
    用来完成对2个数求和

def get_info(name: str, age: int):
    """
    接收用户的名字和年龄，拼接一个字符串并返回

    :param name: 接收一个名字
    :param age: 接收用户的年龄，必须是 0-200 间的一个整数
    :return: 返回拼接好的字符串
    """
    return "我的名字叫 %s，今年是 %d 岁" % (name, age)


get_info("吴彦祖", 19)
get_info(520, 19)  # 注意，形参上标注的类型只是提高代码的可读性，并不会限制实参的类型
help(get_info)

def cal(num):
    result,i = 1,1
    while i <= num:
        result *= i
        i+= 1
    return result

print(cal(3))

1! = 1
2! = 2 × 1 = 2 × 1!
3! = 3 × 2 × 1 = 3 × 2!
4! = 4 × 3 × 2 × 1 = 4 × 3!
...
n! = n × (n-1)!

def factorial(num):
    result = 1
    if num == 1:
        return 1
    result = num * factorial(num -1)
    return result
print(cal(3))

lambda 参数列表: 运算表达式

sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print("Value of total : %d" % sum( 10, 20 ))
print("Value of total : %d" % sum( 20, 20 ))

Value of total :  30
Value of total :  40

>>> def fun(a, b, opt):
...     print("a = " % a)
...     print("b = " % b)
...     print("result =" % opt(a, b))
...
>>> add = lambda x,y:x+y
>>> fun(1, 2, add)  # 把 add 作为实参传递
a = 1
b = 2
result = 3

students = [
    {'name': 'zhangsan', 'age': 18, 'score': 92},
    {'name': 'lisi', 'age': 20, 'score': 90},
    {'name': 'wangwu', 'age': 19, 'score': 95},
    {'name': 'jerry', 'age': 21, 'score': 98},
    {'name': 'chris', 'age': 17, 'score': 100},
]

def test():
    return 'hello world'
print(type(test))  # <class 'function'>

def test():
    return 'hello wrold'

fun = test   # 定义了一个变量fun,让它指向了 test 这个函数
print(fun())   # 使用fun()可以直接调用test这个函数

print(id(fun))  # 1819677672040
print(id(test))  # 1819677672040

def test():
    return 'hello world'

result = test()   # 这种写法是调用test函数，并把函数的返回值赋值给result变量
print(result())   # 这里会报错  TypeError: 'str' object is not callable

fun = test   # 这种写法是给test函数起了一个别名，注意，这里的test后面不能加()
fun()        # 可以使用别名调用这个函数

def test(age,action):
    if age < 18:
        print('您还没满十八岁，请退出')
    action()   # 把参数action直接当做一个函数来调用

def smoke():
    print('我已经年满十八岁了，我想抽烟')

my_action = smoke  # 定义一个变量my_action，让它指向smoke函数
test(21, my_action)  # 将my_action传给 test 函数作为它的参数

test(21,smoke)  # 还可以不再定义一个新的变量，直接传入函数名

def test():
    print('我是test函数里输入的内容')

def demo():
    print('我是demo里输入的内容')
    return test  # test 函数作为demo函数的返回值

result = demo()  # 我是demo里输入的内容  调用 demo 函数，把demo函数的返回值赋值给 result
print(type(result)) # <class 'function'>  result 的类型是一个函数

result() # 我是demo里输入的内容    我是test函数里输入的内容   既然result是一个函数，那么就可以直接使用() 调用这个函数

demo()()  # 我是demo里输入的内容    我是test函数里输入的内容

def outer():
    a = 100
    def inner():  # inner这个函数是在outer函数内部定义的
        b = 200
        b += a #内部函数可以使用外部函数的变量
        #a += b #内部函数不能修改外部函数的变量
        nonlocal a #如果想修改外部函数的变量，需要在内部函数变量前面加上nonlocal
        a += b #此时内部函数可以修改外部函数的变量
    
    result = locals()#locals表示查看函数中的局部变量，已字典的形式返回（详见局部变量，全局变量）
    print(result)
    inner()  # inner函数只在outer函数内部可见

outer()
# inner()  这里会报错，在outer函数外部无法访问到inner函数

a = 100

def outer():
    a = 200
    def inner():
        a = 300
        #nonlocal a ##如果想修改外部函数的变量，需要在内部函数变量前面加上nonlocal
        global a
        a -= 50
        print('内部函数：',a)
    print(a)
    inner()
    
outer()
print(a)

def outer(n):
    num = n
    def inner():
        return num+1
    return inner #返回出去的是inner函数的地址

print(outer(3)())  # 4
print(outer(5)())  # 5

def outer(n):
    num = n
    def inner():
        num = num + 1
        return num
    return inner

print(outer(1)())

UnboundLocalError: local variable 'num' referenced before assignment

def outer(n):
    num = n
    def inner():
        nonlocal num  # 修改前使用nonlocal关键字对 num 变量进行说明
        num = num + 1
        return num
    return inner

print(outer(2)())

def foo():
    print('foo')
    
def func():
    print('func')

foo = func
foo()  # func

#### 第一波 ####
def foo():
    print('foo')

foo  # 表示是函数
foo()  # 表示执行foo函数

#### 第二波 ####
def foo():
    print('foo')

foo = lambda x: x + 1

foo()  # 执行lambda表达式，而不再是原来的foo函数，因为foo这个名字被重新指向了另外一个匿名函数

############### 基础平台提供的功能如下 ###############

def f1():
    print('f1')

def f2():
    print('f2')

def f3():
    print('f3')

def f4():
    print('f4')

############### 业务部门A 调用基础平台提供的功能 ###############

f1()
f2()
f3()
f4()

############### 业务部门B 调用基础平台提供的功能 ###############

f1()
f2()
f3()
f4()

############### 基础平台提供的功能如下 ############### 

def f1():
    # 验证1
    # 验证2
    # 验证3
    print('f1')

def f2():
    # 验证1
    # 验证2
    # 验证3
    print('f2')

def f3():
    # 验证1
    # 验证2
    # 验证3
    print('f3')

def f4():
    # 验证1
    # 验证2
    # 验证3
    print('f4')

############### 业务部门不变 ############### 
### 业务部门A 调用基础平台提供的功能### 

f1()
f2()
f3()
f4()

### 业务部门B 调用基础平台提供的功能 ### 

f1()
f2()
f3()
f4()

############### 基础平台提供的功能如下 ############### 

def check_login():
    # 验证1
    # 验证2
    # 验证3
    pass

def f1():
    check_login()
    print('f1')

def f2():
    check_login()
    print('f2')

def f3():
    check_login()
    print('f3')

def f4():
    check_login()
    print('f4')

def w1(func):
    def inner():
        # 验证1
        # 验证2
        # 验证3
        func()
    return inner

@w1
def f1():
    print('f1')
@w1
def f2():
    print('f2')
@w1
def f3():
    print('f3')
@w1
def f4():
    print('f4')

def w1(func):
    def inner():
        # 验证1
        # 验证2
        # 验证3
        func()
    return inner

@w1 #f1 = w1(f1)
def f1():
    print('f1')

def inner(): 
    #验证 1
    #验证 2
    #验证 3
    f1()    # func是参数，此时 func 等于 f1 
return inner# 返回的 inner，inner代表的是函数，非执行函数 ,其实就是将原来的 f1 函数塞进另外一个函数中

f1 = def inner(): 
            #验证 1
            #验证 2
            #验证 3
            原来f1()
        return inner

# 定义函数：完成包裹数据
def makeBold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped

# 定义函数：完成包裹数据
def makeItalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makeBold
def test1():
    return "hello world-1"

@makeItalic
def test2():
    return "hello world-2"

@makeBold
@makeItalic
def test3():
    return "hello world-3"

print(test1())
print(test2())
print(test3())

<b>hello world-1</b>
<i>hello world-2</i>
<b><i>hello world-3</i></b>

def check_time(action):
    def do_action():
        action()
    return do_action

@check_time
def go_to_bed():
     print('去睡觉')

go_to_bed()

result = check_time(go_to_bed)  # 把go_to_bed 当做参数传入给 check_time函数，再定义一个变量用来保存check_time的运行结果
result()  # check_time 函数的返回值result是一个函数, result()再调用这个函数，让它再调用go_to_bed函数

def check_time(action):
    def do_action(a,b):
        action(a,b)
    return do_action

@check_time
def go_to_bed(a,b):
     print('{}去{}睡觉'.format(a,b))

go_to_bed("zhangsan","床上")

def test(cal):
    def do_cal(*args,**kwargs):
        cal(*args,**kwargs)
    return do_cal

@test
def demo(*args):
    sum = 0
    for x in args:
        sum +=x
    print(sum)

demo(1, 2, 3, 4)

def test(cal):
    def do_cal(*args,**kwargs):
        return cal(*args,**kwargs)  # 需要再这里写return语句，表示调用函数，获取函数的返回值并返回
    return do_cal

@test
def demo(a,b):
    return a + b


print(demo(1, 2))  #3

def outer_check(time):
    def check_time(action):
        def do_action():
            if time < 22:
                return action()
            else:
                return '对不起，您不具有该权限'
        return do_action
    return check_time

@outer_check(23)
def play_game():
    return '玩儿游戏'

print(play_game())

def outer_check(base_permission):
    def check_permission(action):
        def do_action(my_permission):
            if my_permission & base_permission:
                return action(my_permission)
            else:
                return '对不起，您不具有该权限'
        return do_action
    return check_permission

READ_PERMISSION = 1
WRITE_PERMISSION = 2
EXECUTE_PERMISSION = 4

@outer_check(base_permission=READ_PERMISSION)
def read(my_permission):
    return '读取数据'

@outer_check(base_permission=WRITE_PERMISSION)
def write(my_permission):
    return '写入数据'

@outer_check(base_permission=EXECUTE_PERMISSION)
def execute(my_permission):
    return '执行程序'

print(read(5))

import 模块1,模块2,...  # 导入方式

模块名.函数名()  # 使用模块里的函数

import math

#这样才能正确输出结果
print math.sqrt(2)

#这样会报错
print(sqrt(2))

from 模块名 import 函数名1,函数名2....

from fib import fibonacci

from modname import *

In [1]: import time as tt  # 导入模块时设置别名为 tt

In [2]: time.sleep(1)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-2-07a34f5b1e42> in <module>()
----> 1 time.sleep(1)

NameError: name 'time' is not defined

In [3]: 

In [3]: tt.sleep(1)  # 使用别名才能调用方法

In [4]: 

In [4]: from time import sleep as sp  # 导入方法时设置别名

In [5]: sleep(1)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-5-82e5c2913b44> in <module>()
----> 1 sleep(1)

NameError: name 'sleep' is not defined

In [6]: 

In [6]: sp(1)  # 使用别名才能调用方法

In [7]:

import os
os.getcwd()  # 获取当前的工作目录，即当前python脚本工作的目录
os.chdir('test') # 改变当前脚本工作目录，相当于shell下的cd命令
os.rename('毕业论文.txt','毕业论文-最终版.txt') # 文件重命名
os.remove('毕业论文.txt') # 删除文件
os.rmdir('demo')  # 删除空文件夹
os.removedirs('demo') # 删除空文件夹
os.mkdir('demo')  # 创建一个文件夹
os.chdir('C:\\') # 切换工作目录
os.listdir('C:\\') # 列出指定目录里的所有文件和文件夹
os.name # nt->widonws posix->Linux/Unix或者MacOS
os.environ # 获取到环境配置
os.environ.get('PATH') # 获取指定的环境配置

os.path.abspath(path) # 获取Path规范会的绝对路径
os.path.exists(path)  # 如果Path存在，则返回True
os.path.isdir(path)  # 如果path是一个存在的目录，返回True。否则返回False
os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False
os.path.splitext(path)  # 用来将指定路径进行分隔，可以获取到文件的后缀名
Copy

import sys
sys.path # 模块的查找路径
sys.argv # 传递给Python脚本的命令行参数列表
sys.exit(code) # 让程序以指定的退出码结束

sys.stdin # 标准输入。可以通过它来获取用户的输入
sys.stdout # 标准输出。可以通过修改它来百变默认输出
sys.stderr # 错误输出。可以通过修改它来改变错误删除
Copy

import math
print(math.fabs(-100)) # 取绝对值
print(math.ceil(34.01))  #向上取整
print(math.factorial(5)) # 计算阶乘
print(math.floor(34.98))  # 向下取整
print(math.pi)   # π的值，约等于 3.141592653589793
print(math.pow(2, 10)) # 2的10次方
print(math.sin(math.pi / 6))  # 正弦值
print(math.cos(math.pi / 3))  # 余弦值
print(math.tan(math.pi / 2))  # 正切值
Copy

print(random.random())  # 生成 [0,1)的随机浮点数
print(random.uniform(20, 30))  # 生成[20,30]的随机浮点数
print(random.randint(10, 30))  # 生成[10,30]的随机整数
print(random.randrange(20, 30))  # 生成[20,30)的随机整数
print(random.choice('abcdefg'))  # 从列表里随机取出一个元素
print(random.sample('abcdefghij', 3)) # 从列表里随机取出指定个数的元素
Copy

import datetime
print(datetime.date(2020, 1, 1))  # 创建一个日期
print(datetime.time(18, 23, 45)) # 创建一个时间
print(datetime.datetime.now())  # 获取当前的日期时间
print(datetime.datetime.now() + datetime.timedelta(3))  # 计算三天以后的日期时间
Copy

print(time.time())  # 获取从1970-01-01 00:00:00 UTC 到现在时间的秒数
print(time.strftime("%Y-%m-%d %H:%M:%S")) # 按照指定格式输出时间
print(time.asctime()) #Mon Apr 15 20:03:23 2019
print(time.ctime()) # Mon Apr 15 20:03:23 2019

print('hello')
print(time.sleep(10)) # 让线程暂停10秒钟
print('world')
Copy

calendar.setfirstweekday(calendar.SUNDAY) # 设置每周起始日期码。周一到周日分别对应 0 ~ 6
calendar.firstweekday()# 返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一。
c = calendar.calendar(2019)  # 生成2019年的日历，并且以周日为其实日期码
print(c)  #打印2019年日历
print(calendar.isleap(2000)) # True.闰年返回True,否则返回False
count = calendar.leapdays(1996,2010) # 获取1996年到2010年一共有多少个闰年
print(calendar.month(2019, 3))  # 打印2019年3月的日历
Copy

import hashlib

# 待加密信息
str = '这是一个测试'

# 创建md5对象
hl = hashlib.md5('hello'.encode(encoding='utf8'))
print('MD5加密后为 ：' + hl.hexdigest())

h1 = hashlib.sha1('123456'.encode())
print(h1.hexdigest())
h2 = hashlib.sha224('123456'.encode())
print(h2.hexdigest())
h3 = hashlib.sha256('123456'.encode())
print(h3.hexdigest())
h4 = hashlib.sha384('123456'.encode())
print(h4.hexdigest())
Copy

h = hmac.new('h'.encode(),'你好'.encode())
result = h.hexdigest()
print(result)  # 获取加密后的结果
Copy

import copy

nums = [1, 5, 3, 8, [100, 200, 300, 400], 6, 7]
nums1 = copy.copy(nums)  # 对nums列表进行浅复制
nums2 = copy.deepcopy(nums)  # 对nums列表进行深复制
Copy

import uuid

print(uuid.uuid1())  # 根据时间戳和机器码生成uuid,可以保证全球唯一
print(uuid.uuid4())  # 随机生成uuid,可能会有重复

# 使用命名空间和字符串生成uuid.
# 注意一下两点:
# 1. 命名空间不是随意输入的字符串，它也是一个uuid类型的数据
# 2. 相同的命名空间和想到的字符串，生成的uuid是一样的
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'hello'))
print(uuid.uuid5(uuid.NAMESPACE_OID, 'hello'))

pip install ipython # 安装ipython包
Copy

pip install ipython -i https://pypi.douban.com/simple
Copy

[global]
index-url=https://pypi.douban.com/simple
[install]
trusted-host=pypi.douban.com
Copy

pip uninstall ipython # 卸载ipython包
Copy

import sys
print(sys.path)
[
 'C:\\Users\\chris\\Desktop\\Test',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\python37.zip',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\DLLs',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\lib',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37',
 'C:\\Users\\chris\\AppData\\Roaming\\Python\\Python37\\site-packages',
 'C:\\Users\\chris\\AppData\\Local\\Programs\\Python\\Python37\\lib\\site-packages'
]
Copy

a = 'hello'
def fn():
    print('我是test1模块里的fn函数')
Copy

x = '你好'
y = 'good'
def foo():
    print('我是test2模块里的foo函数')
__all__ = ('x','foo')
Copy

m = '早上好'
_n = '下午好'
def _bar():
    print('我是test3里的bar函数')
Copy

from test1 import *
from test2 import *
from test3 import *

print(a)
fn()

print(x)
# print(y) 会报错，test2的__all__里没有变量 y
foo()


print(m)
# print(_n)  会报错，导入test3时， _n 不会被导入

import test3
print(test3._n)  # 也可以强行使用，但是强烈不建议
Copy

def add(a,b):
    return a+b

# 这段代码应该只有直接运行这个文件进行测试时才要执行
# 如果别的代码导入本模块，这段代码不应该被执行
ret = add(12,22)
print('测试的结果是',ret)
Copy

import test1.py   # 只要导入了tets1.py,就会立刻执行 test1.py 代码，打印测试内容
Copy

def add(a,b):
    return a+b

if __name__ == '__main__':  # 只有直接执行这个py文件时,__name__的值才是 __main__
    # 以下代码只有直接运行这个文件才会执行，如果是文件被别的代码导入，下面的代码不会执行
    ret = add(12,22)
    print('测试的结果是',ret)
Copy

def send_msg():
  print('------sendmsg方法被调用了-------')
Copy

def recv_msg():
  print('-----recvmsg方法被调用了--------')
Copy

from . import sendmsg  # 导入指定的模块    . 代表的是当前文件夹
Copy

import newmsg # 导入时，只需要输入包名即可。在包名的__init__.py文件里，导入了指定模块
newmsg.sendmsg.sendm_msg()  # 可以直接调用对应的方法
# newmsg.recvmsg.recv_msg()   不可以使用 recvmsg 模块，因为 __init__.py文件里没有导入这个模块
Copy

__all__ = ["sendmsg","recvmsg"]  # 指定导入的内容
Copy

from newmsg import *  # 将newmsg里的__inint__.py文件里,__all__属性对应的所有模块都导入
sendmsg.sendmsg()
recvmsg.recvmsg()
Copy

print('hello world')
Copy

__all__ = ['sendmsg','recvmsg']

class 类名:
    def 方法1(self,参数列表):
        pass
    def 方法2(self,参数列表):
        pass
Copy

对象变量名 = 类名()
Copy

class Cat:
    """这是个猫类"""

    def eat(self):
        print("小猫在吃东西")

    def drink(self):
        print("小猫在喝水")

tom = Cat()  # 创建了一个Cat对象
tom.eat()
tom.drink()

hello_kitty = Cat()  # 又创建了一个新的Cat对象
hello_kitty.eat()
hello_kitty.drink()
Copy

tom = Cat()
tom.name = 'Tom'  # 可以直接给 tom 对象添加一个 name 属性
Copy

class Cat:
    def eat(self):
        print("%s爱吃鱼" %self.name)

tom = Cat()
tom.name = 'Tom'  # 给 tom 对象添加了一个name属性
tom.eat()  # Tom爱吃鱼

lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat() # 大懒猫爱吃鱼
Copy

tom = Cat()
tom.eat()
tom.anme = "Tom"
Copy

AttributeError: 'Cat' object has no attribute 'name'
错误提示：'Cat'对象没有 'name' 属性
Copy

class Cat:
    """这是一个猫类"""
    def __init__(self,name):  # 重写了 __init__ 魔法方法
        self.name = name

    def eat(self):
        return "%s爱吃鱼"%self.name
    def drink(self):
        return '%s爱喝水'%self.name

    """
        tom = Cat()
        TypeError: __init__() missing 1 required positional argument: 'name'
        这种写法在运行时会直接报错！因为 __init__ 方法里要求在创建对象时，必须要传递 name 属性，如果不传入会直接报错！
    """

tom = Cat("Tom")  # 创建对象时，必须要指定name属性的值
tom.eat()   # tom爱吃鱼

class Student:
    def __init__(self,name,score):
        print('__init__方法被调用了')
        self.name = name
        self.score = score

    def __del__(self):
        print('__del__方法被调用了')
s = Student('lisi',95)
del s
input('请输入内容')

class Student:
    def __init__(self,name,score):
        print('__init__方法被调用了')
        self.name = name
        self.score = score

    def __del__(self):
        print('__del__方法被调用了')
s = Student('lisi',95)
s1 = s
s2 = s
print(sys.getrefcount(s)) #4 PS：调用这个函数也引用一次s

del s1
print("删除s1后的",s.name)
print(sys.getrefcount(s)) #3

del s2
print("删除s2后的",s.name)
print(sys.getrefcount(s)) #2

del s
print("删除s后的",s.name)

class Cat:
    def __init__(self,name,color):
        self.name = name
        self.color = color

tom = Cat('Tom','white')

# 使用 print 方法打印对象时，会调用对象的 __str__ 方法，默认会打印类名和对象的地址名
print(tom)   # <__main__.Cat object at 0x0000021BE3B9C940>
Copy

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return '哈哈'

p  = Person('张三',18)
print(p)   # 哈哈  打印对象时，会自动调用对象的 __str__ 方法
Copy

class Student:
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def __str__(self):
        return '姓名是:{},成绩是{}分'.format(self.name,self.score)

s = Student('lisi',95)
print(s)   # 姓名是:lisi,成绩是95分
Copy

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __repr__(self):
        return 'helllo'


class Person:
    def __repr__(self):
        return 'hi'

    def __str__(self):
        return 'good'


s = Student('lisi', 95)
print(s)  # hello

p = Person()
print(p)  # good
Copy

class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo()  # 执行 __init__
obj()  # 执行 __call__
Copy

class Person:
  def __init__(self,name,age):
    self.name = name
    self.age = age

p1 = Person('zhangsan',18)
p2 = Person('zhangsan',18)
print(p1 == p2)
Copy

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

    # def __ne__(self, other):

    def __lt__(self, other):
        return self.age < other.age

    # def __gt__(self, other):

    def __le__(self, other):
        return self.age <= other.age
    # def __ge__(self, other):


s1 = Student('zhangsan', 18)
s2 = Student('zhangsan', 18)
s3 = Student('lisi', 20)
print(s1 == s2)
print(s1 != s2)
print(s1 > s2)
print(s1 >= s2)
print(s1 <= s2)
print(s1 <= s2)
Copy

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __add__(self, other):
        return self.age + other

    def __sub__(self, other):
        return self.age - other

    def __mul__(self, other):
        return self.age * other

    def __truediv__(self, other):
        return self.age / other

    def __mod__(self, other):
        return self.age % other

    def __pow__(self, power, modulo=None):
        return self.age ** power


s = Student('zhangsan', 18)
print(s + 1)  # 19
print(s - 2)  # 16
print(s * 2)  # 36
print(s / 5)  # 3.6
print(s % 5)  # 3
print(s ** 2)  # 324
Copy

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __int__(self):
        return self.age

    def __float__(self):
        return self.age * 1.0

    def __str__(self):
        return self.name

    def __bool__(self):
        return self.age > 18


s = Student('zhangsan', 18)
print(int(s))
print(float(s))
print(str(s))
print(bool(s))

if s:
    print('hello')

class Person(object):
    __slots__ = ('name', 'age')
    def __init__(self, name, age):
        self.name = name
        self.age = age
p = Person('张三', 18)
p.name = '李四'

# 对象p只能设置name和age属性，不能再动态添加属性
# p.height = 180 # 报错
Copy

class Foo:
    """ 描述类信息，这是用于看片的神奇 """
    def func(self):
        pass

print(Foo.__doc__)
#输出：类的描述信息
Copy

test.py
class Person(object):
    def __init__(self):
        self.name = 'laowang'
main.py
from test import Person

obj = Person()
print(obj.__module__)  # 输出 test 即：输出模块
print(obj.__class__)  # 输出 test.Person 即：输出类
Copy

class Province(object):
    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print('func')

# 获取类的属性，即：类属性、方法、
print(Province.__dict__)
# 输出：{'__dict__': <attribute '__dict__' of 'Province' objects>, '__module__': '__main__', 'country': 'China', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Province' objects>, 'func': <function Province.func at 0x101897950>, '__init__': <function Province.__init__ at 0x1018978c8>}

obj1 = Province('山东', 10000)
print(obj1.__dict__)
# 获取 对象obj1 的属性
# 输出：{'count': 10000, 'name': '山东'}

obj2 = Province('山西', 20000)
print(obj2.__dict__)
# 获取 对象obj1 的属性
# 输出：{'count': 20000, 'name': '山西'}
Copy

class Foo(object):

    def __getitem__(self, key):
        print('__getitem__', key)

    def __setitem__(self, key, value):
        print('__setitem__', key, value)

    def __delitem__(self, key):
        print('__delitem__', key)

obj = Foo()

result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'laowang'   # 自动触发执行 __setitem__
del obj['k1']           # 自动触发执行 __delitem__

class Person(object):
    def __init__(self,name,age):
        # 这里的name和age都属于是实例属性，每个实例在创建时，都有自己的属性
        self.name = name
        self.age = age

# 每创建一个对象，这个对象就有自己的name和age属性
p1 = Person('张三',18)
p2 = Person("李四",20)
Copy

class Dog:
    type = "狗"  # 类属性

dog1 = Dog()
dog2 = Dog()

# 不管是dog1、dog2还是Dog类，都可以访问到type属性
print(Dog.type)  # 结果：狗
print(dog1.type)  # 结果：狗
print(dog2.type)  # 结果：狗
Copy

class Dog(object):
    type = "狗"  # 类属性

    def __init__(self):
        self.type = "dog"  # 对象属性

# 创建对象
dog1 = Dog()

print(dog1.type)     # 结果为 “dog”   类属性和实例属性同名，使用 实例对象 访问的是 实例属性
Copy

lass Dog(object):
    type = "狗"  # 类属性

# 创建对象
dog1 = Dog()
dog1.type = "dog"   # 使用 实例对象 创建了对象属性type

print(dog1.type)     # 结果为 “dog”   类属性和实例属性同名，访问的是实例属性
print(Dog.type)      # 结果为 "狗"   访问类属性

# 只有使用类名才能修改类属性
Dog.type = "土狗"
print(Dog.type)  # 土狗
dog2 = Dog()
print(dog2.type)  # 土狗
Copy

class Dog(object):
    count = 0  # 公有的类属性
    __type = "狗"  # 私有的类属性

print(Dog.count)       # 正确
print(Dog.__type)      # 错误,私有属性，外部无法访问。

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.__money = 2000  # 使用 __ 修饰的属性，是私有属性

    def __shopping(self, cost):
        self.__money -= cost  # __money 只能在对象内部使用
        print('还剩下%d元'%self.__money)

    def test(self):
        self.__shopping(200)  # __shopping 方法也只能在对象内部使用

p = Person('张三',18)
# print(p.__money)   这里会报错，不能直接访问对象内部的私有属性
p.test()
# p.__shopping()  这里会报错，__shopping 只能在对象内部使用，外部无法访问
Copy

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.__money = 2000

    def __shopping(self, cost):
        self.__money -= cost


p = Person('李四',20)
print(p._Person__money)  # 使用对象名._类名__私有属性名 可以直接访问对象的私有属性
p._Person__shopping(100)  # 使用对象名._类名__函数名 可以直接调用对象的私有方法
print(p._Person__money)
Copy

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.__money = 2000  # __money 是私有变量，外部无法访问

    def get_money(self):  # 定义了get_money 方法，在这个方法里获取到 __money
        return self.__money  # 内部可以访问 __money 变量

    def set_money(self,money): # 定义了set_money 方法，在这个方法里，可以修改 __money
        self.__money = money

p = Person('王五',21)

# 外部通过调用 get_money 和 set_money 这两个公开方法获取和修改私有变量
print(p.get_money())
p.set_money(8000)
print(p.get_money())

class Dog(object):
    __type = "狗"

    # 类方法，用classmethod来进行修饰
    @classmethod
    def get_type(cls):
        return cls.__type
print(Dog.get_type())
Copy

class Dog(object):
    type = "狗"

    def __init__(self):
        name = None

    # 静态方法    
    @staticmethod
    def introduce():  # 静态方法不会自动传递实例对象和类对象
        print("犬科哺乳动物,属于食肉目..")

dog1 = Dog()
Dog.introduce()    # 可以用 实例对象 来调用 静态方法
dog1.introduce()    # 可以用 类对象 来调用 静态方法
Copy

class Dog:

    def demo_method(self):
        print("对象方法")

    @classmethod
    def demo_method(cls):
        print("类方法")

    @staticmethod
    def demo_method():  # 被最后定义
        print("静态方法")

dog1 = Dog()
Dog.demo_method()  # 结果: 静态方法
dog1.demo_method()  # 结果: 静态方法

class A(object):
    def __init__(self):
        print("这是 init 方法")

    def __new__(cls):
        print("这是 new 方法")
        return object.__new__(cls)

A()

# 实例化一个单例
class Singleton(object):
    __instance = None
    __is_first = True

    def __new__(cls, age, name):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, age, name):
        if self. __is_first: # 不会再创建第二个对象
            self.age = age
            self.name = name
            Singleton. __is_first = False


a = Singleton(18, "张三")
b = Singleton(28, "张三")

print(id(a))
print(id(b))

print(a.age) # 18
print(b.age) # 18

a.age = 19
print(b.age)

class Animal:
    def __int__(self):
        pass
    """动物类"""
    def sleep(self):
        print('正在睡觉')


class Dog(Animal):
    """Dog类继承自Animal类"""
    def __init__(self):
        pass

class Cat(Animal):  # 定义类时，在括号后面传入父类的类名，表示子类继承父类
    """Cat类继承自Animal类"""
    def __int__(self):
        pass

# Dog 和 Cat 都继承自Animal类，可以直接使用Animal类里的sleep方法
dog = Dog()
dog.sleep()

cat = Cat()
cat.sleep()

class 类名(父类名):
    pass
Copy

class 子类名(父类名1,父类名2...)
    pass
Copy

print(C.__mro__)

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

class 类名(object):
    pass

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


p1 = Person('张三', 18)
p2 = Person('张三', 18)
p3 = p1

print(p1 is p2)  # False
print(p1 is p3)  # True
Copy

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Student(Person):
    def __init__(self, name, age, score):
        super(Student, self).__init__(name, age)
        self.score = score


class Dog(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color


p = Person('tony', 18)
s = Student('jack', 20, 90)
d = Dog('旺财', '白色')

print(isinstance(p, Person))  # True.对象p是由Person类创建出来的
print(isinstance(s, Person))  # True.对象s是有Person类的子类创建出来的
print(isinstance(d, Person))  # False.对象d和Person类没有关系
Copy

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Student(Person):
    def __init__(self, name, age, score):
        super(Student, self).__init__(name, age)
        self.score = score


class Dog(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color


print(issubclass(Student, Person))  # True
print(issubclass(Dog, Person))  # False

class ArmyDog(object):

    def bite_enemy(self):
        print('追击敌人')

class DrugDog(object):

    def track_drug(self):
        print('追查毒品')

class Person(object):

    def work_with_army(self, dog):
        dog.bite_enemy()

    def work_with_drug(self, dog):
        dog.track_drug()

ad = ArmyDog()
dd = DrugDog()

p = Person()
p.work_with_army(ad)
p.work_with_drug(dd)

class XiaoTianDog(object):

    def eat_moon(self):
        print('哮天犬把月亮吃了')

class Person(object):

    def work_with_xiaotian(self, dog):  # 添加方法
        dog.eat_moon()

class Dog(object):

    def work(self):  # 父类提供统一的方法，哪怕是空方法
        pass

class ArmyDog(Dog):   # 继承 Dog

    def work(self):  # 子类重写方法，并且处理自己的行为
        print('追击敌人')

class DrugDog(Dog):

    def work(self):
        print('追查毒品')

class Person(object):

    def work_with_dog(self, dog):
        dog.work()    # 使用小狗可以根据对象的不同而产生不同的运行效果, 保障了代码的稳定性

# 子类对象可以当作父类来使用
dog = Dog()
ad = ArmyDog()
dd = DrugDog()


p = Person()
p.work_with_dog(dog)
p.work_with_dog(ad)  # 同一个方法，只要是 Dog 的子类就可以传递，提供了代码的灵活性
p.work_with_dog(dd)  # 并且传递不同对象，最终 work_with_dog 产生了不同的执行效果